X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=r_shadow.c;h=8e6958522cdb9fcc4763ea084bcdd7e512f7a973;hb=1e4fe28814b6fcdaf1c8c35a805fb221dd860ec4;hp=9d103b0f6da9cf6622c15c8540e122c350de6da9;hpb=e2f3aafe7b60f54c50f29d0358132034cfb21e07;p=xonotic%2Fdarkplaces.git

diff --git a/r_shadow.c b/r_shadow.c
index 9d103b0f..8e695852 100644
--- a/r_shadow.c
+++ b/r_shadow.c
@@ -140,25 +140,66 @@ demonstrated by the game Doom3.
 #include "portals.h"
 #include "image.h"
 
+#ifdef SUPPORTD3D
+#include <d3d9.h>
+extern LPDIRECT3DDEVICE9 vid_d3d9dev;
+#endif
+
 extern void R_Shadow_EditLights_Init(void);
 
 typedef enum r_shadow_rendermode_e
 {
 	R_SHADOW_RENDERMODE_NONE,
-	R_SHADOW_RENDERMODE_STENCIL,
-	R_SHADOW_RENDERMODE_SEPARATESTENCIL,
-	R_SHADOW_RENDERMODE_STENCILTWOSIDE,
+	R_SHADOW_RENDERMODE_ZPASS_STENCIL,
+	R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
+	R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
+	R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
+	R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
+	R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
 	R_SHADOW_RENDERMODE_LIGHT_VERTEX,
-	R_SHADOW_RENDERMODE_LIGHT_DOT3,
+	R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN,
+	R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN,
+	R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN,
 	R_SHADOW_RENDERMODE_LIGHT_GLSL,
 	R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
 	R_SHADOW_RENDERMODE_VISIBLELIGHTING,
+	R_SHADOW_RENDERMODE_SHADOWMAP2D
 }
 r_shadow_rendermode_t;
 
+typedef enum r_shadow_shadowmode_e
+{
+    R_SHADOW_SHADOWMODE_STENCIL,
+    R_SHADOW_SHADOWMODE_SHADOWMAP2D
+}
+r_shadow_shadowmode_t;
+
 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
-r_shadow_rendermode_t r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_NONE;
+r_shadow_rendermode_t r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_NONE;
+r_shadow_rendermode_t r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_NONE;
+qboolean r_shadow_usingshadowmap2d;
+qboolean r_shadow_usingshadowmaportho;
+int r_shadow_shadowmapside;
+float r_shadow_shadowmap_texturescale[2];
+float r_shadow_shadowmap_parameters[4];
+#if 0
+int r_shadow_drawbuffer;
+int r_shadow_readbuffer;
+#endif
+int r_shadow_cullface_front, r_shadow_cullface_back;
+GLuint r_shadow_fbo2d;
+r_shadow_shadowmode_t r_shadow_shadowmode;
+int r_shadow_shadowmapfilterquality;
+int r_shadow_shadowmapdepthbits;
+int r_shadow_shadowmapmaxsize;
+qboolean r_shadow_shadowmapvsdct;
+qboolean r_shadow_shadowmapsampler;
+int r_shadow_shadowmappcf;
+int r_shadow_shadowmapborder;
+matrix4x4_t r_shadow_shadowmapmatrix;
+int r_shadow_lightscissor[4];
+qboolean r_shadow_usingdeferredprepass;
 
 int maxshadowtriangles;
 int *shadowelements;
@@ -172,18 +213,25 @@ int *shadowmark;
 int *shadowmarklist;
 int shadowmarkcount;
 
+int maxshadowsides;
+int numshadowsides;
+unsigned char *shadowsides;
+int *shadowsideslist;
+
 int maxvertexupdate;
 int *vertexupdate;
 int *vertexremap;
 int vertexupdatenum;
 
 int r_shadow_buffer_numleafpvsbytes;
+unsigned char *r_shadow_buffer_visitingleafpvs;
 unsigned char *r_shadow_buffer_leafpvs;
 int *r_shadow_buffer_leaflist;
 
 int r_shadow_buffer_numsurfacepvsbytes;
 unsigned char *r_shadow_buffer_surfacepvs;
 int *r_shadow_buffer_surfacelist;
+unsigned char *r_shadow_buffer_surfacesides;
 
 int r_shadow_buffer_numshadowtrispvsbytes;
 unsigned char *r_shadow_buffer_shadowtrispvs;
@@ -194,7 +242,22 @@ rtexturepool_t *r_shadow_texturepool;
 rtexture_t *r_shadow_attenuationgradienttexture;
 rtexture_t *r_shadow_attenuation2dtexture;
 rtexture_t *r_shadow_attenuation3dtexture;
-rtexture_t *r_shadow_lightcorona;
+skinframe_t *r_shadow_lightcorona;
+rtexture_t *r_shadow_shadowmap2dtexture;
+rtexture_t *r_shadow_shadowmap2dcolortexture;
+rtexture_t *r_shadow_shadowmapvsdcttexture;
+int r_shadow_shadowmapsize; // changes for each light based on distance
+int r_shadow_shadowmaplod; // changes for each light based on distance
+
+GLuint r_shadow_prepassgeometryfbo;
+GLuint r_shadow_prepasslightingfbo;
+int r_shadow_prepass_width;
+int r_shadow_prepass_height;
+rtexture_t *r_shadow_prepassgeometrydepthtexture;
+rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
+rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
+rtexture_t *r_shadow_prepasslightingdiffusetexture;
+rtexture_t *r_shadow_prepasslightingspeculartexture;
 
 // lights are reloaded when this changes
 char r_shadow_mapname[MAX_QPATH];
@@ -202,20 +265,26 @@ char r_shadow_mapname[MAX_QPATH];
 // used only for light filters (cubemaps)
 rtexturepool_t *r_shadow_filters_texturepool;
 
+static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
+
 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"};
 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"};
 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
+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"};
+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)"};
+//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"};
 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
 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)"};
 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"};
 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
+cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
+cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
-cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
-cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
+cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "0", "how far to cast shadows"};
 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)"};
 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
@@ -226,14 +295,29 @@ cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_
 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
 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"};
-cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation"};
-cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation"};
+cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};
+cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "0", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
 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)"};
-cvar_t r_shadow_culltriangles = {0, "r_shadow_culltriangles", "1", "performs more expensive tests to remove unnecessary triangles of lit surfaces"};
+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"};
+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)"};
+cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
+cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
+cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
+cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
+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"};
+//cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
+//cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
+cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
+cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
+cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
+cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
+cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
 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)"};
-cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect r_glsl lighting)"};
+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)"};
 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
+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"};
+cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
@@ -260,20 +344,10 @@ static memexpandablearray_t r_shadow_worldlightsarray;
 dlight_t *r_shadow_selectedlight;
 dlight_t r_shadow_bufferlight;
 vec3_t r_editlights_cursorlocation;
+qboolean r_editlights_lockcursor;
 
 extern int con_vislines;
 
-typedef struct cubemapinfo_s
-{
-	char basename[64];
-	rtexture_t *texture;
-}
-cubemapinfo_t;
-
-#define MAX_CUBEMAPS 256
-static int numcubemaps;
-static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
-
 void R_Shadow_UncompileWorldLights(void);
 void R_Shadow_ClearWorldLights(void);
 void R_Shadow_SaveWorldLights(void);
@@ -284,22 +358,139 @@ void R_Shadow_EditLights_Reload_f(void);
 void R_Shadow_ValidateCvars(void);
 static void R_Shadow_MakeTextures(void);
 
-// VorteX: custom editor light sprites
 #define EDLIGHTSPRSIZE			8
-cachepic_t *r_editlights_sprcursor;
-cachepic_t *r_editlights_sprlight;
-cachepic_t *r_editlights_sprnoshadowlight;
-cachepic_t *r_editlights_sprcubemaplight;
-cachepic_t *r_editlights_sprcubemapnoshadowlight;
-cachepic_t *r_editlights_sprselection;
+skinframe_t *r_editlights_sprcursor;
+skinframe_t *r_editlights_sprlight;
+skinframe_t *r_editlights_sprnoshadowlight;
+skinframe_t *r_editlights_sprcubemaplight;
+skinframe_t *r_editlights_sprcubemapnoshadowlight;
+skinframe_t *r_editlights_sprselection;
+
+void R_Shadow_SetShadowMode(void)
+{
+	r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
+	r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
+	r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
+	r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
+	r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
+	r_shadow_shadowmaplod = -1;
+	r_shadow_shadowmapsize = 0;
+	r_shadow_shadowmapsampler = false;
+	r_shadow_shadowmappcf = 0;
+	r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
+	if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
+	{
+		switch(vid.renderpath)
+		{
+		case RENDERPATH_GL20:
+			if(r_shadow_shadowmapfilterquality < 0)
+			{
+				if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
+					r_shadow_shadowmappcf = 1;
+				else if(strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD")) 
+				{
+					r_shadow_shadowmapsampler = vid.support.arb_shadow;
+					r_shadow_shadowmappcf = 1;
+				}
+				else if(strstr(gl_vendor, "ATI")) 
+					r_shadow_shadowmappcf = 1;
+				else 
+					r_shadow_shadowmapsampler = vid.support.arb_shadow;
+			}
+			else 
+			{
+				switch (r_shadow_shadowmapfilterquality)
+				{
+				case 1:
+					r_shadow_shadowmapsampler = vid.support.arb_shadow;
+					break;
+				case 2:
+					r_shadow_shadowmapsampler = vid.support.arb_shadow;
+					r_shadow_shadowmappcf = 1;
+					break;
+				case 3:
+					r_shadow_shadowmappcf = 1;
+					break;
+				case 4:
+					r_shadow_shadowmappcf = 2;
+					break;
+				}
+			}
+			r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
+			// Cg has very little choice in depth texture sampling
+			if (vid.cgcontext)
+				r_shadow_shadowmapsampler = false;
+			break;
+		case RENDERPATH_CGGL:
+		case RENDERPATH_D3D9:
+		case RENDERPATH_D3D10:
+		case RENDERPATH_D3D11:
+			r_shadow_shadowmapsampler = false;
+			r_shadow_shadowmappcf = 1;
+			r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
+			break;
+		case RENDERPATH_GL13:
+			break;
+		case RENDERPATH_GL11:
+			break;
+		}
+	}
+}
+
+qboolean R_Shadow_ShadowMappingEnabled(void)
+{
+	switch (r_shadow_shadowmode)
+	{
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		return true;
+	default:
+		return false;
+	}
+}
+
+void R_Shadow_FreeShadowMaps(void)
+{
+	R_Shadow_SetShadowMode();
+
+	R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
+
+	r_shadow_fbo2d = 0;
+
+	if (r_shadow_shadowmap2dtexture)
+		R_FreeTexture(r_shadow_shadowmap2dtexture);
+	r_shadow_shadowmap2dtexture = NULL;
+
+	if (r_shadow_shadowmap2dcolortexture)
+		R_FreeTexture(r_shadow_shadowmap2dcolortexture);
+	r_shadow_shadowmap2dcolortexture = NULL;
+
+	if (r_shadow_shadowmapvsdcttexture)
+		R_FreeTexture(r_shadow_shadowmapvsdcttexture);
+	r_shadow_shadowmapvsdcttexture = NULL;
+}
 
 void r_shadow_start(void)
 {
 	// allocate vertex processing arrays
-	numcubemaps = 0;
 	r_shadow_attenuationgradienttexture = NULL;
 	r_shadow_attenuation2dtexture = NULL;
 	r_shadow_attenuation3dtexture = NULL;
+	r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
+	r_shadow_shadowmap2dtexture = NULL;
+	r_shadow_shadowmap2dcolortexture = NULL;
+	r_shadow_shadowmapvsdcttexture = NULL;
+	r_shadow_shadowmapmaxsize = 0;
+	r_shadow_shadowmapsize = 0;
+	r_shadow_shadowmaplod = 0;
+	r_shadow_shadowmapfilterquality = -1;
+	r_shadow_shadowmapdepthbits = 0;
+	r_shadow_shadowmapvsdct = false;
+	r_shadow_shadowmapsampler = false;
+	r_shadow_shadowmappcf = 0;
+	r_shadow_fbo2d = 0;
+
+	R_Shadow_FreeShadowMaps();
+
 	r_shadow_texturepool = NULL;
 	r_shadow_filters_texturepool = NULL;
 	R_Shadow_ValidateCvars();
@@ -317,22 +508,41 @@ void r_shadow_start(void)
 	shadowmark = NULL;
 	shadowmarklist = NULL;
 	shadowmarkcount = 0;
+	maxshadowsides = 0;
+	numshadowsides = 0;
+	shadowsides = NULL;
+	shadowsideslist = NULL;
 	r_shadow_buffer_numleafpvsbytes = 0;
+	r_shadow_buffer_visitingleafpvs = NULL;
 	r_shadow_buffer_leafpvs = NULL;
 	r_shadow_buffer_leaflist = NULL;
 	r_shadow_buffer_numsurfacepvsbytes = 0;
 	r_shadow_buffer_surfacepvs = NULL;
 	r_shadow_buffer_surfacelist = NULL;
+	r_shadow_buffer_surfacesides = NULL;
 	r_shadow_buffer_numshadowtrispvsbytes = 0;
 	r_shadow_buffer_shadowtrispvs = NULL;
 	r_shadow_buffer_numlighttrispvsbytes = 0;
 	r_shadow_buffer_lighttrispvs = NULL;
+
+	r_shadow_usingdeferredprepass = false;
+	r_shadow_prepass_width = r_shadow_prepass_height = 0;
 }
 
+static void R_Shadow_FreeDeferred(void);
 void r_shadow_shutdown(void)
 {
+	CHECKGLERROR
 	R_Shadow_UncompileWorldLights();
-	numcubemaps = 0;
+
+	R_Shadow_FreeShadowMaps();
+
+	r_shadow_usingdeferredprepass = false;
+	if (r_shadow_prepass_width)
+		R_Shadow_FreeDeferred();
+	r_shadow_prepass_width = r_shadow_prepass_height = 0;
+
+	CHECKGLERROR
 	r_shadow_attenuationgradienttexture = NULL;
 	r_shadow_attenuation2dtexture = NULL;
 	r_shadow_attenuation3dtexture = NULL;
@@ -362,7 +572,18 @@ void r_shadow_shutdown(void)
 		Mem_Free(shadowmarklist);
 	shadowmarklist = NULL;
 	shadowmarkcount = 0;
+	maxshadowsides = 0;
+	numshadowsides = 0;
+	if (shadowsides)
+		Mem_Free(shadowsides);
+	shadowsides = NULL;
+	if (shadowsideslist)
+		Mem_Free(shadowsideslist);
+	shadowsideslist = NULL;
 	r_shadow_buffer_numleafpvsbytes = 0;
+	if (r_shadow_buffer_visitingleafpvs)
+		Mem_Free(r_shadow_buffer_visitingleafpvs);
+	r_shadow_buffer_visitingleafpvs = NULL;
 	if (r_shadow_buffer_leafpvs)
 		Mem_Free(r_shadow_buffer_leafpvs);
 	r_shadow_buffer_leafpvs = NULL;
@@ -376,6 +597,9 @@ void r_shadow_shutdown(void)
 	if (r_shadow_buffer_surfacelist)
 		Mem_Free(r_shadow_buffer_surfacelist);
 	r_shadow_buffer_surfacelist = NULL;
+	if (r_shadow_buffer_surfacesides)
+		Mem_Free(r_shadow_buffer_surfacesides);
+	r_shadow_buffer_surfacesides = NULL;
 	r_shadow_buffer_numshadowtrispvsbytes = 0;
 	if (r_shadow_buffer_shadowtrispvs)
 		Mem_Free(r_shadow_buffer_shadowtrispvs);
@@ -386,41 +610,15 @@ void r_shadow_shutdown(void)
 
 void r_shadow_newmap(void)
 {
-}
-
-void R_Shadow_Help_f(void)
-{
-	Con_Printf(
-"Documentation on r_shadow system:\n"
-"Settings:\n"
-"r_shadow_bumpscale_basetexture : base texture as bumpmap with this scale\n"
-"r_shadow_bumpscale_bumpmap : depth scale for bumpmap conversion\n"
-"r_shadow_debuglight : render only this light number (-1 = all)\n"
-"r_shadow_gloss 0/1/2 : no gloss, gloss textures only, force gloss\n"
-"r_shadow_gloss2intensity : brightness of forced gloss\n"
-"r_shadow_glossintensity : brightness of textured gloss\n"
-"r_shadow_lightattenuationlinearscale : used to generate attenuation texture\n"
-"r_shadow_lightattenuationdividebias : used to generate attenuation texture\n"
-"r_shadow_lightintensityscale : scale rendering brightness of all lights\n"
-"r_shadow_lightradiusscale : scale rendering radius of all lights\n"
-"r_shadow_portallight : use portal visibility for static light precomputation\n"
-"r_shadow_projectdistance : shadow volume projection distance\n"
-"r_shadow_realtime_dlight : use high quality dynamic lights in normal mode\n"
-"r_shadow_realtime_dlight_shadows : cast shadows from dlights\n"
-"r_shadow_realtime_world : use high quality world lighting mode\n"
-"r_shadow_realtime_world_lightmaps : use lightmaps in addition to lights\n"
-"r_shadow_realtime_world_shadows : cast shadows from world lights\n"
-"r_shadow_realtime_world_compile : compile surface/visibility information\n"
-"r_shadow_realtime_world_compileshadow : compile shadow geometry\n"
-"r_shadow_scissor : use scissor optimization\n"
-"r_shadow_polygonfactor : nudge shadow volumes closer/further\n"
-"r_shadow_polygonoffset : nudge shadow volumes closer/further\n"
-"r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n"
-"r_showlighting : useful for performance testing; bright = slow!\n"
-"r_showshadowvolumes : useful for performance testing; bright = slow!\n"
-"Commands:\n"
-"r_shadow_help : this help\n"
-	);
+	if (r_shadow_lightcorona)                 R_SkinFrame_MarkUsed(r_shadow_lightcorona);
+	if (r_editlights_sprcursor)               R_SkinFrame_MarkUsed(r_editlights_sprcursor);
+	if (r_editlights_sprlight)                R_SkinFrame_MarkUsed(r_editlights_sprlight);
+	if (r_editlights_sprnoshadowlight)        R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
+	if (r_editlights_sprcubemaplight)         R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
+	if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
+	if (r_editlights_sprselection)            R_SkinFrame_MarkUsed(r_editlights_sprselection);
+	if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
+		R_Shadow_EditLights_Reload_f();
 }
 
 void R_Shadow_Init(void)
@@ -429,15 +627,19 @@ void R_Shadow_Init(void)
 	Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
 	Cvar_RegisterVariable(&r_shadow_usenormalmap);
 	Cvar_RegisterVariable(&r_shadow_debuglight);
+	Cvar_RegisterVariable(&r_shadow_deferred);
+	Cvar_RegisterVariable(&r_shadow_deferred_8bitrange);
+//	Cvar_RegisterVariable(&r_shadow_deferred_fp);
 	Cvar_RegisterVariable(&r_shadow_gloss);
 	Cvar_RegisterVariable(&r_shadow_gloss2intensity);
 	Cvar_RegisterVariable(&r_shadow_glossintensity);
 	Cvar_RegisterVariable(&r_shadow_glossexponent);
+	Cvar_RegisterVariable(&r_shadow_gloss2exponent);
+	Cvar_RegisterVariable(&r_shadow_glossexact);
 	Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
 	Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
 	Cvar_RegisterVariable(&r_shadow_lightintensityscale);
 	Cvar_RegisterVariable(&r_shadow_lightradiusscale);
-	Cvar_RegisterVariable(&r_shadow_portallight);
 	Cvar_RegisterVariable(&r_shadow_projectdistance);
 	Cvar_RegisterVariable(&r_shadow_frontsidecasting);
 	Cvar_RegisterVariable(&r_shadow_realtime_dlight);
@@ -452,11 +654,26 @@ void R_Shadow_Init(void)
 	Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
 	Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
 	Cvar_RegisterVariable(&r_shadow_scissor);
-	Cvar_RegisterVariable(&r_shadow_culltriangles);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
+//	Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
+//	Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
+	Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
 	Cvar_RegisterVariable(&r_shadow_polygonfactor);
 	Cvar_RegisterVariable(&r_shadow_polygonoffset);
 	Cvar_RegisterVariable(&r_shadow_texture3d);
 	Cvar_RegisterVariable(&r_coronas);
+	Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
+	Cvar_RegisterVariable(&r_coronas_occlusionquery);
 	Cvar_RegisterVariable(&gl_flashblend);
 	Cvar_RegisterVariable(&gl_ext_separatestencil);
 	Cvar_RegisterVariable(&gl_ext_stenciltwoside);
@@ -465,7 +682,6 @@ void R_Shadow_Init(void)
 		Cvar_SetValue("r_shadow_gloss", 2);
 		Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
 	}
-	Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f, "prints documentation on console commands and variables used by realtime lighting and shadowing system");
 	R_Shadow_EditLights_Init();
 	Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
 	maxshadowtriangles = 0;
@@ -481,15 +697,21 @@ void R_Shadow_Init(void)
 	shadowmark = NULL;
 	shadowmarklist = NULL;
 	shadowmarkcount = 0;
+	maxshadowsides = 0;
+	numshadowsides = 0;
+	shadowsides = NULL;
+	shadowsideslist = NULL;
 	r_shadow_buffer_numleafpvsbytes = 0;
+	r_shadow_buffer_visitingleafpvs = NULL;
 	r_shadow_buffer_leafpvs = NULL;
 	r_shadow_buffer_leaflist = NULL;
 	r_shadow_buffer_numsurfacepvsbytes = 0;
 	r_shadow_buffer_surfacepvs = NULL;
 	r_shadow_buffer_surfacelist = NULL;
+	r_shadow_buffer_surfacesides = NULL;
 	r_shadow_buffer_shadowtrispvs = NULL;
 	r_shadow_buffer_lighttrispvs = NULL;
-	R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
+	R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
 }
 
 matrix4x4_t matrix_attenuationxyz =
@@ -512,15 +734,17 @@ matrix4x4_t matrix_attenuationz =
 	}
 };
 
-void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles)
+void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
 {
+	numvertices = ((numvertices + 255) & ~255) * vertscale;
+	numtriangles = ((numtriangles + 255) & ~255) * triscale;
 	// make sure shadowelements is big enough for this volume
 	if (maxshadowtriangles < numtriangles)
 	{
 		maxshadowtriangles = numtriangles;
 		if (shadowelements)
 			Mem_Free(shadowelements);
-		shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[24]));
+		shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
 	}
 	// make sure shadowvertex3f is big enough for this volume
 	if (maxshadowvertices < numvertices)
@@ -528,7 +752,7 @@ void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles)
 		maxshadowvertices = numvertices;
 		if (shadowvertex3f)
 			Mem_Free(shadowvertex3f);
-		shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[6]));
+		shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
 	}
 }
 
@@ -540,11 +764,14 @@ static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces,
 	int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
 	if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
 	{
+		if (r_shadow_buffer_visitingleafpvs)
+			Mem_Free(r_shadow_buffer_visitingleafpvs);
 		if (r_shadow_buffer_leafpvs)
 			Mem_Free(r_shadow_buffer_leafpvs);
 		if (r_shadow_buffer_leaflist)
 			Mem_Free(r_shadow_buffer_leaflist);
 		r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
+		r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
 		r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
 		r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
 	}
@@ -554,9 +781,12 @@ static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces,
 			Mem_Free(r_shadow_buffer_surfacepvs);
 		if (r_shadow_buffer_surfacelist)
 			Mem_Free(r_shadow_buffer_surfacelist);
+		if (r_shadow_buffer_surfacesides)
+			Mem_Free(r_shadow_buffer_surfacesides);
 		r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
 		r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
 		r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
+		r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
 	}
 	if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
 	{
@@ -598,7 +828,22 @@ void R_Shadow_PrepareShadowMark(int numtris)
 	numshadowmark = 0;
 }
 
-int R_Shadow_ConstructShadowVolume(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)
+void R_Shadow_PrepareShadowSides(int numtris)
+{
+    if (maxshadowsides < numtris)
+    {
+        maxshadowsides = numtris;
+        if (shadowsides)
+			Mem_Free(shadowsides);
+		if (shadowsideslist)
+			Mem_Free(shadowsideslist);
+		shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
+		shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
+	}
+	numshadowsides = 0;
+}
+
+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)
 {
 	int i, j;
 	int outtriangles = 0, outvertices = 0;
@@ -611,28 +856,6 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 	else
 		VectorClear(projectvector);
 
-	if (maxvertexupdate < innumvertices)
-	{
-		maxvertexupdate = innumvertices;
-		if (vertexupdate)
-			Mem_Free(vertexupdate);
-		if (vertexremap)
-			Mem_Free(vertexremap);
-		vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
-		vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
-		vertexupdatenum = 0;
-	}
-	vertexupdatenum++;
-	if (vertexupdatenum == 0)
-	{
-		vertexupdatenum = 1;
-		memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
-		memset(vertexremap, 0, maxvertexupdate * sizeof(int));
-	}
-
-	for (i = 0;i < numshadowmarktris;i++)
-		shadowmark[shadowmarktris[i]] = shadowmarkcount;
-
 	// create the vertices
 	if (projectdirection)
 	{
@@ -817,22 +1040,114 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 	return outtriangles;
 }
 
-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)
+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)
 {
-	int tris, outverts;
-	if (projectdistance < 0.1)
+	int i, j, k;
+	int outtriangles = 0, outvertices = 0;
+	const int *element;
+	const float *vertex;
+	float ratio, direction[3], projectvector[3];
+	qboolean side[4];
+
+	if (projectdirection)
+		VectorScale(projectdirection, projectdistance, projectvector);
+	else
+		VectorClear(projectvector);
+
+	for (i = 0;i < numshadowmarktris;i++)
 	{
-		Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
-		return;
+		int remappedelement[3];
+		int markindex;
+		const int *neighbortriangle;
+
+		markindex = shadowmarktris[i] * 3;
+		neighbortriangle = inneighbor3i + markindex;
+		side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
+		side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
+		side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
+		if (side[0] + side[1] + side[2] == 0)
+			continue;
+
+		side[3] = side[0];
+		element = inelement3i + markindex;
+
+		// create the vertices
+		for (j = 0;j < 3;j++)
+		{
+			if (side[j] + side[j+1] == 0)
+				continue;
+			k = element[j];
+			if (vertexupdate[k] != vertexupdatenum)
+			{
+				vertexupdate[k] = vertexupdatenum;
+				vertexremap[k] = outvertices;
+				vertex = invertex3f + k * 3;
+				VectorCopy(vertex, outvertex3f);
+				if (projectdirection)
+				{
+					// project one copy of the vertex according to projectvector
+					VectorAdd(vertex, projectvector, (outvertex3f + 3));
+				}
+				else
+				{
+					// project one copy of the vertex to the sphere radius of the light
+					// (FIXME: would projecting it to the light box be better?)
+					VectorSubtract(vertex, projectorigin, direction);
+					ratio = projectdistance / VectorLength(direction);
+					VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
+				}
+				outvertex3f += 6;
+				outvertices += 2;
+			}
+		}
+
+		// output the sides (facing outward from this triangle)
+		if (!side[0])
+		{
+			remappedelement[0] = vertexremap[element[0]];
+			remappedelement[1] = vertexremap[element[1]];
+			outelement3i[0] = remappedelement[1];
+			outelement3i[1] = remappedelement[0];
+			outelement3i[2] = remappedelement[0] + 1;
+			outelement3i[3] = remappedelement[1];
+			outelement3i[4] = remappedelement[0] + 1;
+			outelement3i[5] = remappedelement[1] + 1;
+
+			outelement3i += 6;
+			outtriangles += 2;
+		}
+		if (!side[1])
+		{
+			remappedelement[1] = vertexremap[element[1]];
+			remappedelement[2] = vertexremap[element[2]];
+			outelement3i[0] = remappedelement[2];
+			outelement3i[1] = remappedelement[1];
+			outelement3i[2] = remappedelement[1] + 1;
+			outelement3i[3] = remappedelement[2];
+			outelement3i[4] = remappedelement[1] + 1;
+			outelement3i[5] = remappedelement[2] + 1;
+
+			outelement3i += 6;
+			outtriangles += 2;
+		}
+		if (!side[2])
+		{
+			remappedelement[0] = vertexremap[element[0]];
+			remappedelement[2] = vertexremap[element[2]];
+			outelement3i[0] = remappedelement[0];
+			outelement3i[1] = remappedelement[2];
+			outelement3i[2] = remappedelement[2] + 1;
+			outelement3i[3] = remappedelement[0];
+			outelement3i[4] = remappedelement[2] + 1;
+			outelement3i[5] = remappedelement[0] + 1;
+
+			outelement3i += 6;
+			outtriangles += 2;
+		}
 	}
-	if (!numverts || !nummarktris)
-		return;
-	// make sure shadowelements is big enough for this volume
-	if (maxshadowtriangles < nummarktris || maxshadowvertices < numverts)
-		R_Shadow_ResizeShadowArrays((numverts + 255) & ~255, (nummarktris + 255) & ~255);
-	tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
-	r_refdef.stats.lights_dynamicshadowtriangles += tris;
-	R_Shadow_RenderVolume(outverts, tris, shadowvertex3f, shadowelements);
+	if (outnumvertices)
+		*outnumvertices = outvertices;
+	return outtriangles;
 }
 
 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)
@@ -894,125 +1209,649 @@ void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *inv
 	}
 }
 
-void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i)
+qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
 {
-	if (r_shadow_compilingrtlight)
+#if 1
+	return false;
+#else
+	if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
+		return false;
+	// check if the shadow volume intersects the near plane
+	//
+	// a ray between the eye and light origin may intersect the caster,
+	// indicating that the shadow may touch the eye location, however we must
+	// test the near plane (a polygon), not merely the eye location, so it is
+	// easiest to enlarge the caster bounding shape slightly for this.
+	// TODO
+	return true;
+#endif
+}
+
+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)
+{
+	int i, tris, outverts;
+	if (projectdistance < 0.1)
 	{
-		// if we're compiling an rtlight, capture the mesh
-		Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i);
+		Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
 		return;
 	}
-	r_refdef.stats.lights_shadowtriangles += numtriangles;
-	CHECKGLERROR
-	R_Mesh_VertexPointer(vertex3f, 0, 0);
-	GL_LockArrays(0, numvertices);
-	if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL)
-	{
-		// decrement stencil if backface is behind depthbuffer
-		GL_CullFace(r_view.cullface_front);
-		qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
-		R_Mesh_Draw(0, numvertices, numtriangles, element3i, 0, 0);
-		// increment stencil if frontface is behind depthbuffer
-		GL_CullFace(r_view.cullface_back);
-		qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
-	}
-	R_Mesh_Draw(0, numvertices, numtriangles, element3i, 0, 0);
-	GL_LockArrays(0, 0);
-	CHECKGLERROR
-}
+	if (!numverts || !nummarktris)
+		return;
+	// make sure shadowelements is big enough for this volume
+	if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
+		R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
 
-static void R_Shadow_MakeTextures_MakeCorona(void)
-{
-	float dx, dy;
-	int x, y, a;
-	unsigned char pixels[32][32][4];
-	for (y = 0;y < 32;y++)
+	if (maxvertexupdate < numverts)
 	{
-		dy = (y - 15.5f) * (1.0f / 16.0f);
-		for (x = 0;x < 32;x++)
+		maxvertexupdate = numverts;
+		if (vertexupdate)
+			Mem_Free(vertexupdate);
+		if (vertexremap)
+			Mem_Free(vertexremap);
+		vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
+		vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
+		vertexupdatenum = 0;
+	}
+	vertexupdatenum++;
+	if (vertexupdatenum == 0)
+	{
+		vertexupdatenum = 1;
+		memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
+		memset(vertexremap, 0, maxvertexupdate * sizeof(int));
+	}
+
+	for (i = 0;i < nummarktris;i++)
+		shadowmark[marktris[i]] = shadowmarkcount;
+
+	if (r_shadow_compilingrtlight)
+	{
+		// if we're compiling an rtlight, capture the mesh
+		//tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
+		//Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
+		tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
+		Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
+	}
+	else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
+	{
+		tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
+		R_Mesh_PrepareVertices_Position_Arrays(outverts, shadowvertex3f);
+		R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
+	}
+	else
+	{
+		// decide which type of shadow to generate and set stencil mode
+		R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
+		// generate the sides or a solid volume, depending on type
+		if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
+			tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
+		else
+			tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
+		r_refdef.stats.lights_dynamicshadowtriangles += tris;
+		r_refdef.stats.lights_shadowtriangles += tris;
+		if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
 		{
-			dx = (x - 15.5f) * (1.0f / 16.0f);
-			a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
-			a = bound(0, a, 255);
-			pixels[y][x][0] = a;
-			pixels[y][x][1] = a;
-			pixels[y][x][2] = a;
-			pixels[y][x][3] = 255;
+			// increment stencil if frontface is infront of depthbuffer
+			GL_CullFace(r_refdef.view.cullface_front);
+			R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
+			R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
+			// decrement stencil if backface is infront of depthbuffer
+			GL_CullFace(r_refdef.view.cullface_back);
+			R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
+		}
+		else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
+		{
+			// decrement stencil if backface is behind depthbuffer
+			GL_CullFace(r_refdef.view.cullface_front);
+			R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
+			R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
+			// increment stencil if frontface is behind depthbuffer
+			GL_CullFace(r_refdef.view.cullface_back);
+			R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
 		}
+		R_Mesh_PrepareVertices_Position_Arrays(outverts, shadowvertex3f);
+		R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
 	}
-	r_shadow_lightcorona = R_LoadTexture2D(r_shadow_texturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE, NULL);
 }
 
-static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
+int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
 {
-	float dist = sqrt(x*x+y*y+z*z);
-	float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
-	// note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
-	return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
+    // p1, p2, p3 are in the cubemap's local coordinate system
+    // bias = border/(size - border)
+	int mask = 0x3F;
+
+    float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
+    	  dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
+    	  dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
+	if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
+    	mask &= (3<<4)
+			| (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
+			| (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
+			| (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
+    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
+        mask &= (3<<4)
+            | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
+            | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))            
+            | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
+
+    dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
+    dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
+    dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
+    if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
+        mask &= (3<<0)
+            | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
+            | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))            
+            | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
+    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
+        mask &= (3<<0)
+            | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
+            | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
+            | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
+
+    dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
+    dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
+    dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
+    if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
+        mask &= (3<<2)
+            | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
+            | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
+            | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
+    if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
+        mask &= (3<<2)
+            | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
+            | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
+            | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
+
+	return mask;
 }
 
-static void R_Shadow_MakeTextures(void)
+int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
 {
-	int x, y, z;
-	float intensity, dist;
-	unsigned int *data;
-	R_FreeTexturePool(&r_shadow_texturepool);
-	r_shadow_texturepool = R_AllocTexturePool();
-	r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
-	r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
-	data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
-	// the table includes one additional value to avoid the need to clamp indexing due to minor math errors
-	for (x = 0;x <= ATTENTABLESIZE;x++)
-	{
-		dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
-		intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
-		r_shadow_attentable[x] = bound(0, intensity, 1);
-	}
-	// 1D gradient texture
-	for (x = 0;x < ATTEN1DSIZE;x++)
-		data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
-	r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
-	// 2D circle texture
-	for (y = 0;y < ATTEN2DSIZE;y++)
-		for (x = 0;x < ATTEN2DSIZE;x++)
-			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);
-	r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
-	// 3D sphere texture
-	if (r_shadow_texture3d.integer && gl_texture3d)
-	{
-		for (z = 0;z < ATTEN3DSIZE;z++)
-			for (y = 0;y < ATTEN3DSIZE;y++)
-				for (x = 0;x < ATTEN3DSIZE;x++)
-					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));
-		r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
-	}
-	else
-		r_shadow_attenuation3dtexture = NULL;
-	Mem_Free(data);
+	vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
+	float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
+	int mask = 0x3F;
+
+	VectorSubtract(maxs, mins, radius);
+    VectorScale(radius, 0.5f, radius);
+    VectorAdd(mins, radius, center);
+    Matrix4x4_Transform(worldtolight, center, lightcenter);
+	Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
+	VectorSubtract(lightcenter, lightradius, pmin);
+	VectorAdd(lightcenter, lightradius, pmax);
+
+    dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
+    dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
+    if(ap1 > bias*an1 && ap2 > bias*an2)
+        mask &= (3<<4)
+            | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
+            | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
+    if(an1 > bias*ap1 && an2 > bias*ap2)
+        mask &= (3<<4)
+            | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
+            | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
+
+    dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
+    dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
+    if(ap1 > bias*an1 && ap2 > bias*an2)
+        mask &= (3<<0)
+            | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
+            | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
+    if(an1 > bias*ap1 && an2 > bias*ap2)
+        mask &= (3<<0)
+            | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
+            | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
+
+    dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
+    dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
+    if(ap1 > bias*an1 && ap2 > bias*an2)
+        mask &= (3<<2)
+            | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
+            | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
+    if(an1 > bias*ap1 && an2 > bias*ap2)
+        mask &= (3<<2)
+            | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
+            | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
+
+    return mask;
+}
 
-	R_Shadow_MakeTextures_MakeCorona();
+#define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
 
-	// Editor light sprites
-	r_editlights_sprcursor = Draw_CachePic("gfx/editlights/cursor", true);
-	r_editlights_sprlight = Draw_CachePic("gfx/editlights/light", true);
-	r_editlights_sprnoshadowlight = Draw_CachePic("gfx/editlights/noshadow", true);
-	r_editlights_sprcubemaplight = Draw_CachePic("gfx/editlights/cubemaplight", true);
-	r_editlights_sprcubemapnoshadowlight = Draw_CachePic("gfx/editlights/cubemapnoshadowlight", true);
-	r_editlights_sprselection = Draw_CachePic("gfx/editlights/selection", true);
+int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
+{
+    // p is in the cubemap's local coordinate system
+    // bias = border/(size - border)
+    float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
+    float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
+    float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
+    int mask = 0x3F;
+    if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
+    if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
+    if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
+    if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
+    if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
+    if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
+    return mask;
 }
 
-void R_Shadow_ValidateCvars(void)
+int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
 {
-	if (r_shadow_texture3d.integer && !gl_texture3d)
-		Cvar_SetValueQuick(&r_shadow_texture3d, 0);
-	if (gl_ext_separatestencil.integer && !gl_support_separatestencil)
-		Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
-	if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside)
-		Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
+	int i;
+	vec3_t p, n;
+	int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
+	float scale = (size - 2*border)/size, len;
+	float bias = border / (float)(size - border), dp, dn, ap, an;
+	// check if cone enclosing side would cross frustum plane 
+	scale = 2 / (scale*scale + 2);
+	for (i = 0;i < 5;i++)
+	{
+		if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
+			continue;
+		Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
+		len = scale*VectorLength2(n);
+		if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
+		if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
+		if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
+	}
+	if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
+	{
+        Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
+        len = scale*VectorLength(n);
+		if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
+		if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
+		if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
+	}
+	// this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
+	// check if frustum corners/origin cross plane sides
+#if 1
+    // infinite version, assumes frustum corners merely give direction and extend to infinite distance
+    Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
+    dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
+    masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
+    masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
+    dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
+    masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
+    masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
+    dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
+    masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
+    masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
+    for (i = 0;i < 4;i++)
+    {
+        Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
+        VectorSubtract(n, p, n);
+        dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
+        if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
+        if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
+        dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
+        if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
+        if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
+        dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
+        if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
+        if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
+    }
+#else
+    // finite version, assumes corners are a finite distance from origin dependent on far plane
+	for (i = 0;i < 5;i++)
+	{
+		Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
+		dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
+		masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
+		masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
+		dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
+		masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
+		masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
+		dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
+		masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
+		masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
+	}
+#endif
+	return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
 }
 
-void R_Shadow_RenderMode_Begin(void)
+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)
 {
+	int t, tend;
+	const int *e;
+	const float *v[3];
+	float normal[3];
+	vec3_t p[3];
+	float bias;
+	int mask, surfacemask = 0;
+	if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
+		return 0;
+	bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
+	tend = firsttriangle + numtris;
+	if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
+	{
+		// surface box entirely inside light box, no box cull
+		if (projectdirection)
+		{
+			for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
+			{
+				v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
+				TriangleNormal(v[0], v[1], v[2], normal);
+				if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
+				{
+					Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
+					mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
+					surfacemask |= mask;
+					if(totals)
+					{
+						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;
+						shadowsides[numshadowsides] = mask;
+						shadowsideslist[numshadowsides++] = t;
+					}
+				}
+			}
+		}
+		else
+		{
+			for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
+			{
+				v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,	v[2] = invertex3f + e[2] * 3;
+				if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
+				{
+					Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
+					mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
+					surfacemask |= mask;
+					if(totals)
+					{
+						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;
+						shadowsides[numshadowsides] = mask;
+						shadowsideslist[numshadowsides++] = t;
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		// surface box not entirely inside light box, cull each triangle
+		if (projectdirection)
+		{
+			for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
+			{
+				v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,	v[2] = invertex3f + e[2] * 3;
+				TriangleNormal(v[0], v[1], v[2], normal);
+				if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
+				 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
+				{
+					Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
+					mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
+					surfacemask |= mask;
+					if(totals)
+					{
+						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;
+						shadowsides[numshadowsides] = mask;
+						shadowsideslist[numshadowsides++] = t;
+					}
+				}
+			}
+		}
+		else
+		{
+			for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
+			{
+				v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
+				if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
+				 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
+				{
+					Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
+					mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
+					surfacemask |= mask;
+					if(totals)
+					{
+						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;
+						shadowsides[numshadowsides] = mask;
+						shadowsideslist[numshadowsides++] = t;
+					}
+				}
+			}
+		}
+	}
+	return surfacemask;
+}
+
+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)
+{
+	int i, j, outtriangles = 0;
+	int *outelement3i[6];
+	if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
+		return;
+	outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
+	// make sure shadowelements is big enough for this mesh
+	if (maxshadowtriangles < outtriangles)
+		R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
+
+	// compute the offset and size of the separate index lists for each cubemap side
+	outtriangles = 0;
+	for (i = 0;i < 6;i++)
+	{
+		outelement3i[i] = shadowelements + outtriangles * 3;
+		r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
+		r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
+		outtriangles += sidetotals[i];
+	}
+
+	// gather up the (sparse) triangles into separate index lists for each cubemap side
+	for (i = 0;i < numsidetris;i++)
+	{
+		const int *element = elements + sidetris[i] * 3;
+		for (j = 0;j < 6;j++)
+		{
+			if (sides[i] & (1 << j))
+			{
+				outelement3i[j][0] = element[0];
+				outelement3i[j][1] = element[1];
+				outelement3i[j][2] = element[2];
+				outelement3i[j] += 3;
+			}
+		}
+	}
+			
+	Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
+}
+
+static void R_Shadow_MakeTextures_MakeCorona(void)
+{
+	float dx, dy;
+	int x, y, a;
+	unsigned char pixels[32][32][4];
+	for (y = 0;y < 32;y++)
+	{
+		dy = (y - 15.5f) * (1.0f / 16.0f);
+		for (x = 0;x < 32;x++)
+		{
+			dx = (x - 15.5f) * (1.0f / 16.0f);
+			a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
+			a = bound(0, a, 255);
+			pixels[y][x][0] = a;
+			pixels[y][x][1] = a;
+			pixels[y][x][2] = a;
+			pixels[y][x][3] = 255;
+		}
+	}
+	r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32);
+}
+
+static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
+{
+	float dist = sqrt(x*x+y*y+z*z);
+	float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
+	// note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
+	return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
+}
+
+static void R_Shadow_MakeTextures(void)
+{
+	int x, y, z;
+	float intensity, dist;
+	unsigned int *data;
+	R_Shadow_FreeShadowMaps();
+	R_FreeTexturePool(&r_shadow_texturepool);
+	r_shadow_texturepool = R_AllocTexturePool();
+	r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
+	r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
+	data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
+	// the table includes one additional value to avoid the need to clamp indexing due to minor math errors
+	for (x = 0;x <= ATTENTABLESIZE;x++)
+	{
+		dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
+		intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
+		r_shadow_attentable[x] = bound(0, intensity, 1);
+	}
+	// 1D gradient texture
+	for (x = 0;x < ATTEN1DSIZE;x++)
+		data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
+	r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
+	// 2D circle texture
+	for (y = 0;y < ATTEN2DSIZE;y++)
+		for (x = 0;x < ATTEN2DSIZE;x++)
+			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);
+	r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
+	// 3D sphere texture
+	if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
+	{
+		for (z = 0;z < ATTEN3DSIZE;z++)
+			for (y = 0;y < ATTEN3DSIZE;y++)
+				for (x = 0;x < ATTEN3DSIZE;x++)
+					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));
+		r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
+	}
+	else
+		r_shadow_attenuation3dtexture = NULL;
+	Mem_Free(data);
+
+	R_Shadow_MakeTextures_MakeCorona();
+
+	// Editor light sprites
+	r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
+	"................"
+	".3............3."
+	"..5...2332...5.."
+	"...7.3....3.7..."
+	"....7......7...."
+	"...3.7....7.3..."
+	"..2...7..7...2.."
+	"..3..........3.."
+	"..3..........3.."
+	"..2...7..7...2.."
+	"...3.7....7.3..."
+	"....7......7...."
+	"...7.3....3.7..."
+	"..5...2332...5.."
+	".3............3."
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+	r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
+	"................"
+	"................"
+	"......1111......"
+	"....11233211...."
+	"...1234554321..."
+	"...1356776531..."
+	"..124677776421.."
+	"..135777777531.."
+	"..135777777531.."
+	"..124677776421.."
+	"...1356776531..."
+	"...1234554321..."
+	"....11233211...."
+	"......1111......"
+	"................"
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+	r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
+	"................"
+	"................"
+	"......1111......"
+	"....11233211...."
+	"...1234554321..."
+	"...1356226531..."
+	"..12462..26421.."
+	"..1352....2531.."
+	"..1352....2531.."
+	"..12462..26421.."
+	"...1356226531..."
+	"...1234554321..."
+	"....11233211...."
+	"......1111......"
+	"................"
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+	r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
+	"................"
+	"................"
+	"......2772......"
+	"....27755772...."
+	"..277533335772.."
+	"..753333333357.."
+	"..777533335777.."
+	"..735775577537.."
+	"..733357753337.."
+	"..733337733337.."
+	"..753337733357.."
+	"..277537735772.."
+	"....27777772...."
+	"......2772......"
+	"................"
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+	r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
+	"................"
+	"................"
+	"......2772......"
+	"....27722772...."
+	"..2772....2772.."
+	"..72........27.."
+	"..7772....2777.."
+	"..7.27722772.7.."
+	"..7...2772...7.."
+	"..7....77....7.."
+	"..72...77...27.."
+	"..2772.77.2772.."
+	"....27777772...."
+	"......2772......"
+	"................"
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+	r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
+	"................"
+	".777752..257777."
+	".742........247."
+	".72..........27."
+	".7............7."
+	".5............5."
+	".2............2."
+	"................"
+	"................"
+	".2............2."
+	".5............5."
+	".7............7."
+	".72..........27."
+	".742........247."
+	".777752..257777."
+	"................"
+	, 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
+}
+
+void R_Shadow_ValidateCvars(void)
+{
+	if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
+		Cvar_SetValueQuick(&r_shadow_texture3d, 0);
+	if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
+		Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
+	if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
+		Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
+}
+
+//static const r_vertexposition_t resetvertexposition[3] = {{0, 0, 0}};
+
+void R_Shadow_RenderMode_Begin(void)
+{
+#if 0
+	GLint drawbuffer;
+	GLint readbuffer;
+#endif
 	R_Shadow_ValidateCvars();
 
 	if (!r_shadow_attenuation2dtexture
@@ -1022,142 +1861,383 @@ void R_Shadow_RenderMode_Begin(void)
 		R_Shadow_MakeTextures();
 
 	CHECKGLERROR
-	R_Mesh_ColorPointer(NULL, 0, 0);
 	R_Mesh_ResetTextureState();
+//	R_Mesh_PrepareVertices_Position(0, resetvertexposition, NULL);
 	GL_BlendFunc(GL_ONE, GL_ZERO);
 	GL_DepthRange(0, 1);
 	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	GL_DepthTest(true);
 	GL_DepthMask(false);
 	GL_Color(0, 0, 0, 1);
-	GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
+	GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
 
 	r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
 
-	if (gl_ext_separatestencil.integer)
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_SEPARATESTENCIL;
-	else if (gl_ext_stenciltwoside.integer)
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCILTWOSIDE;
+	if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
+	{
+		r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
+		r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
+	}
+	else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
+	{
+		r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
+		r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
+	}
 	else
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCIL;
+	{
+		r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
+		r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
+	}
 
-	if (r_glsl.integer && gl_support_fragment_shader)
+	switch(vid.renderpath)
+	{
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+	case RENDERPATH_D3D9:
+	case RENDERPATH_D3D10:
+	case RENDERPATH_D3D11:
 		r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
-	else if (gl_dot3arb && gl_texturecubemap && r_textureunits.integer >= 2 && gl_combine.integer && gl_stencil)
-		r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_DOT3;
-	else
-		r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
+		break;
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL11:
+		if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
+			r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
+		else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
+			r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
+		else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
+			r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
+		else
+			r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
+		break;
+	}
+
+	CHECKGLERROR
+#if 0
+	qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
+	qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
+	r_shadow_drawbuffer = drawbuffer;
+	r_shadow_readbuffer = readbuffer;
+#endif
+	r_shadow_cullface_front = r_refdef.view.cullface_front;
+	r_shadow_cullface_back = r_refdef.view.cullface_back;
 }
 
-void R_Shadow_RenderMode_ActiveLight(rtlight_t *rtlight)
+void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
 {
 	rsurface.rtlight = rtlight;
 }
 
 void R_Shadow_RenderMode_Reset(void)
 {
-	CHECKGLERROR
-	if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
-	{
-		qglUseProgramObjectARB(0);CHECKGLERROR
-	}
-	else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE)
-	{
-		qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
-	}
-	R_Mesh_ColorPointer(NULL, 0, 0);
+	R_Mesh_ResetRenderTargets();
+	R_SetViewport(&r_refdef.view.viewport);
+	GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
 	R_Mesh_ResetTextureState();
+//	R_Mesh_PrepareVertices_Position(0, resetvertexposition, NULL);
 	GL_DepthRange(0, 1);
 	GL_DepthTest(true);
 	GL_DepthMask(false);
-	qglDepthFunc(GL_LEQUAL);CHECKGLERROR
+	GL_DepthFunc(GL_LEQUAL);
 	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
-	qglDisable(GL_STENCIL_TEST);CHECKGLERROR
-	qglStencilMask(~0);CHECKGLERROR
-	qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
-	qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
-	GL_CullFace(r_view.cullface_back);
+	r_refdef.view.cullface_front = r_shadow_cullface_front;
+	r_refdef.view.cullface_back = r_shadow_cullface_back;
+	GL_CullFace(r_refdef.view.cullface_back);
 	GL_Color(1, 1, 1, 1);
-	GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
+	GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
 	GL_BlendFunc(GL_ONE, GL_ZERO);
+	R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
+	r_shadow_usingshadowmap2d = false;
+	r_shadow_usingshadowmaportho = false;
+	R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
 }
 
-void R_Shadow_RenderMode_StencilShadowVolumes(qboolean clearstencil)
+void R_Shadow_ClearStencil(void)
 {
-	CHECKGLERROR
+	GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 128);
+	r_refdef.stats.lights_clears++;
+}
+
+void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
+{
+	r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
+	if (r_shadow_rendermode == mode)
+		return;
 	R_Shadow_RenderMode_Reset();
+	GL_DepthFunc(GL_LESS);
 	GL_ColorMask(0, 0, 0, 0);
 	GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
-	qglDepthFunc(GL_LESS);CHECKGLERROR
-	qglEnable(GL_STENCIL_TEST);CHECKGLERROR
-	r_shadow_rendermode = r_shadow_shadowingrendermode;
-	if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SEPARATESTENCIL)
+	GL_CullFace(GL_NONE);
+	R_SetupShader_DepthOrShadow();
+	r_shadow_rendermode = mode;
+	switch(mode)
+	{
+	default:
+		break;
+	case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
+	case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
+		R_SetStencilSeparate(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, GL_ALWAYS, 128, 255);
+		break;
+	case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
+	case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
+		R_SetStencilSeparate(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, GL_ALWAYS, 128, 255);
+		break;
+	}
+}
+
+static void R_Shadow_MakeVSDCT(void)
+{
+	// maps to a 2x3 texture rectangle with normalized coordinates
+	// +-
+	// XX
+	// YY
+	// ZZ
+	// stores abs(dir.xy), offset.xy/2.5
+	unsigned char data[4*6] =
+	{
+		255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
+		255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
+		0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
+		0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
+		0,   0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
+		0,   0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
+	};
+	r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
+}
+
+static void R_Shadow_MakeShadowMap(int side, int size)
+{
+	switch (r_shadow_shadowmode)
 	{
-		GL_CullFace(GL_NONE);
-		qglStencilOpSeparate(r_view.cullface_front, GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
-		qglStencilOpSeparate(r_view.cullface_back, GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		if (r_shadow_shadowmap2dtexture) return;
+		r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
+		r_shadow_shadowmap2dcolortexture = NULL;
+		switch(vid.renderpath)
+		{
+#ifdef SUPPORTD3D
+		case RENDERPATH_D3D9:
+			r_shadow_shadowmap2dcolortexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_BGRA, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
+			r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
+			break;
+#endif
+		default:
+			r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, NULL, NULL, NULL, NULL);
+			break;
+		}
+		break;
+	default:
+		return;
 	}
-	else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE)
+
+	// render depth into the fbo, do not render color at all
+	// validate the fbo now
+	if (qglDrawBuffer)
 	{
-		GL_CullFace(GL_NONE);
-		qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
-		qglActiveStencilFaceEXT(r_view.cullface_front);CHECKGLERROR
-		qglStencilMask(~0);CHECKGLERROR
-		qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
-		qglActiveStencilFaceEXT(r_view.cullface_back);CHECKGLERROR
-		qglStencilMask(~0);CHECKGLERROR
-		qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
-	}
-	if (clearstencil)
-		GL_Clear(GL_STENCIL_BUFFER_BIT);
-	r_refdef.stats.lights_clears++;
+		int status;
+		qglDrawBuffer(GL_NONE);CHECKGLERROR
+		qglReadBuffer(GL_NONE);CHECKGLERROR
+		status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
+		if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
+		{
+			Con_Printf("R_Shadow_MakeShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
+			Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
+			Cvar_SetValueQuick(&r_shadow_deferred, 0);
+		}
+	}
 }
 
-void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent)
+void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
 {
-	CHECKGLERROR
+	float nearclip, farclip, bias;
+	r_viewport_t viewport;
+	int flipped;
+	GLuint fbo = 0;
+	float clearcolor[4];
+	nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
+	farclip = 1.0f;
+	bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
+	r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
+	r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
+	r_shadow_shadowmapside = side;
+	r_shadow_shadowmapsize = size;
+
+	r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
+	r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
+	R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
+	if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
+
+	// complex unrolled cube approach (more flexible)
+	if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
+		R_Shadow_MakeVSDCT();
+	if (!r_shadow_shadowmap2dtexture)
+		R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
+	if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
+	r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
+	r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
+	r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
+
+	R_Mesh_ResetTextureState();
+	R_Mesh_ResetRenderTargets();
 	R_Shadow_RenderMode_Reset();
-	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-	if (!transparent)
+	if (fbo)
 	{
-		qglDepthFunc(GL_EQUAL);CHECKGLERROR
+		R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
+		R_SetupShader_DepthOrShadow();
 	}
-	if (stenciltest)
+	else
+		R_SetupShader_ShowDepth();
+	GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
+	GL_DepthMask(true);
+	GL_DepthTest(true);
+
+init_done:
+	R_SetViewport(&viewport);
+	flipped = (side & 1) ^ (side >> 2);
+	r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
+	r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
+	switch(vid.renderpath)
+	{
+	case RENDERPATH_GL11:
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+		GL_CullFace(r_refdef.view.cullface_back);
+		// OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
+		if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
+		{
+			// get tightest scissor rectangle that encloses all viewports in the clear mask
+			int x1 = clear & 0x15 ? 0 : size;
+			int x2 = clear & 0x2A ? 2 * size : size;
+			int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
+			int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
+			GL_Scissor(x1, y1, x2 - x1, y2 - y1);
+			GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
+		}
+		GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
+		break;
+	case RENDERPATH_D3D9:
+		Vector4Set(clearcolor, 1,1,1,1);
+		// completely different meaning than in OpenGL path
+		r_shadow_shadowmap_parameters[1] = 0;
+		r_shadow_shadowmap_parameters[3] = -bias;
+		// we invert the cull mode because we flip the projection matrix
+		// NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
+		GL_CullFace(r_refdef.view.cullface_front);
+		// D3D considers it an error to use a scissor larger than the viewport...  clear just this view
+		GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
+		if (r_shadow_shadowmapsampler)
+		{
+			GL_ColorMask(0,0,0,0);
+			if (clear)
+				GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
+		}
+		else
+		{
+			GL_ColorMask(1,1,1,1);
+			if (clear)
+				GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
+		}
+		break;
+	case RENDERPATH_D3D10:
+	case RENDERPATH_D3D11:
+		// D3D considers it an error to use a scissor larger than the viewport...  clear just this view
+		GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
+		GL_ColorMask(0,0,0,0);
+		if (clear)
+			GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
+		break;
+	}
+}
+
+void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
+{
+	R_Mesh_ResetTextureState();
+	R_Mesh_ResetRenderTargets();
+	if (transparent)
 	{
-		qglEnable(GL_STENCIL_TEST);CHECKGLERROR
-		// only draw light where this geometry was already rendered AND the
-		// stencil is 128 (values other than this mean shadow)
-		qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
+		r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
+		r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
+		r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
+		r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
 	}
-	r_shadow_rendermode = r_shadow_lightingrendermode;
+	R_Shadow_RenderMode_Reset();
+	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+	if (!transparent)
+		GL_DepthFunc(GL_EQUAL);
 	// do global setup needed for the chosen lighting mode
 	if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
-	{
-		R_Mesh_TexBind(0, R_GetTexture(r_texture_blanknormalmap)); // normal
-		R_Mesh_TexBind(1, R_GetTexture(r_texture_white)); // diffuse
-		R_Mesh_TexBind(2, R_GetTexture(r_texture_white)); // gloss
-		R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap)); // light filter
-		R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation)); // fog
-		R_Mesh_TexBind(5, R_GetTexture(r_texture_white)); // pants
-		R_Mesh_TexBind(6, R_GetTexture(r_texture_white)); // shirt
-		R_Mesh_TexBind(7, R_GetTexture(r_texture_white)); // lightmap
-		R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap)); // deluxemap
-		R_Mesh_TexBind(9, R_GetTexture(r_texture_black)); // glow
-		//R_Mesh_TexMatrix(3, rsurface.entitytolight); // light filter matrix
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 0);
-		CHECKGLERROR
-	}
+		GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
+	r_shadow_usingshadowmap2d = shadowmapping;
+	r_shadow_rendermode = r_shadow_lightingrendermode;
+	// only draw light where this geometry was already rendered AND the
+	// stencil is 128 (values other than this mean shadow)
+	if (stenciltest)
+		R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
+	else
+		R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
+}
+
+static const unsigned short bboxelements[36] =
+{
+	5, 1, 3, 5, 3, 7,
+	6, 2, 0, 6, 0, 4,
+	7, 3, 2, 7, 2, 6,
+	4, 0, 1, 4, 1, 5,
+	4, 5, 7, 4, 7, 6,
+	1, 0, 2, 1, 2, 3,
+};
+
+static const float bboxpoints[8][3] =
+{
+	{-1,-1,-1},
+	{ 1,-1,-1},
+	{-1, 1,-1},
+	{ 1, 1,-1},
+	{-1,-1, 1},
+	{ 1,-1, 1},
+	{-1, 1, 1},
+	{ 1, 1, 1},
+};
+
+void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
+{
+	int i;
+	float vertex3f[8*3];
+	const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
+// do global setup needed for the chosen lighting mode
+	R_Shadow_RenderMode_Reset();
+	r_shadow_rendermode = r_shadow_lightingrendermode;
+	R_EntityMatrix(&identitymatrix);
+	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+	// only draw light where this geometry was already rendered AND the
+	// stencil is 128 (values other than this mean shadow)
+	R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
+	R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+
+	r_shadow_usingshadowmap2d = shadowmapping;
+
+	// render the lighting
+	R_SetupShader_DeferredLight(rsurface.rtlight);
+	for (i = 0;i < 8;i++)
+		Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
+	GL_ColorMask(1,1,1,1);
+	GL_DepthMask(false);
+	GL_DepthRange(0, 1);
+	GL_PolygonOffset(0, 0);
+	GL_DepthTest(true);
+	GL_DepthFunc(GL_GREATER);
+	GL_CullFace(r_refdef.view.cullface_back);
+	R_Mesh_PrepareVertices_Position_Arrays(8, vertex3f);
+	R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
 }
 
 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
 {
-	CHECKGLERROR
 	R_Shadow_RenderMode_Reset();
 	GL_BlendFunc(GL_ONE, GL_ONE);
 	GL_DepthRange(0, 1);
 	GL_DepthTest(r_showshadowvolumes.integer < 2);
-	GL_Color(0.0, 0.0125 * r_view.colorscale, 0.1 * r_view.colorscale, 1);
+	GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
 	GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
 	GL_CullFace(GL_NONE);
 	r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
@@ -1165,85 +2245,118 @@ void R_Shadow_RenderMode_VisibleShadowVolumes(void)
 
 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
 {
-	CHECKGLERROR
 	R_Shadow_RenderMode_Reset();
 	GL_BlendFunc(GL_ONE, GL_ONE);
 	GL_DepthRange(0, 1);
 	GL_DepthTest(r_showlighting.integer < 2);
-	GL_Color(0.1 * r_view.colorscale, 0.0125 * r_view.colorscale, 0, 1);
+	GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
 	if (!transparent)
-	{
-		qglDepthFunc(GL_EQUAL);CHECKGLERROR
-	}
-	if (stenciltest)
-	{
-		qglEnable(GL_STENCIL_TEST);CHECKGLERROR
-		qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
-	}
+		GL_DepthFunc(GL_EQUAL);
+	R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
 	r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
 }
 
 void R_Shadow_RenderMode_End(void)
 {
-	CHECKGLERROR
 	R_Shadow_RenderMode_Reset();
 	R_Shadow_RenderMode_ActiveLight(NULL);
 	GL_DepthMask(true);
-	GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
+	GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
 	r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
 }
 
+int bboxedges[12][2] =
+{
+	// top
+	{0, 1}, // +X
+	{0, 2}, // +Y
+	{1, 3}, // Y, +X
+	{2, 3}, // X, +Y
+	// bottom
+	{4, 5}, // +X
+	{4, 6}, // +Y
+	{5, 7}, // Y, +X
+	{6, 7}, // X, +Y
+	// verticals
+	{0, 4}, // +Z
+	{1, 5}, // X, +Z
+	{2, 6}, // Y, +Z
+	{3, 7}, // XY, +Z
+};
+
 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
 {
 	int i, ix1, iy1, ix2, iy2;
 	float x1, y1, x2, y2;
 	vec4_t v, v2;
-	rmesh_t mesh;
-	mplane_t planes[11];
-	float vertex3f[256*3];
+	float vertex[20][3];
+	int j, k;
+	vec4_t plane4f;
+	int numvertices;
+	float corner[8][4];
+	float dist[8];
+	int sign[8];
+	float f;
+
+	r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
+	r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
+	r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
+	r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
+
+	if (!r_shadow_scissor.integer)
+		return false;
 
 	// if view is inside the light box, just say yes it's visible
-	if (BoxesOverlap(r_view.origin, r_view.origin, mins, maxs))
-	{
-		GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
+	if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
 		return false;
+
+	x1 = y1 = x2 = y2 = 0;
+
+	// transform all corners that are infront of the nearclip plane
+	VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
+	plane4f[3] = r_refdef.view.frustum[4].dist;
+	numvertices = 0;
+	for (i = 0;i < 8;i++)
+	{
+		Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
+		dist[i] = DotProduct4(corner[i], plane4f);
+		sign[i] = dist[i] > 0;
+		if (!sign[i])
+		{
+			VectorCopy(corner[i], vertex[numvertices]);
+			numvertices++;
+		}
+	}
+	// if some points are behind the nearclip, add clipped edge points to make
+	// sure that the scissor boundary is complete
+	if (numvertices > 0 && numvertices < 8)
+	{
+		// add clipped edge points
+		for (i = 0;i < 12;i++)
+		{
+			j = bboxedges[i][0];
+			k = bboxedges[i][1];
+			if (sign[j] != sign[k])
+			{
+				f = dist[j] / (dist[j] - dist[k]);
+				VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
+				numvertices++;
+			}
+		}
 	}
 
-	// create a temporary brush describing the area the light can affect in worldspace
-	VectorNegate(r_view.frustum[0].normal, planes[ 0].normal);planes[ 0].dist = -r_view.frustum[0].dist;
-	VectorNegate(r_view.frustum[1].normal, planes[ 1].normal);planes[ 1].dist = -r_view.frustum[1].dist;
-	VectorNegate(r_view.frustum[2].normal, planes[ 2].normal);planes[ 2].dist = -r_view.frustum[2].dist;
-	VectorNegate(r_view.frustum[3].normal, planes[ 3].normal);planes[ 3].dist = -r_view.frustum[3].dist;
-	VectorNegate(r_view.frustum[4].normal, planes[ 4].normal);planes[ 4].dist = -r_view.frustum[4].dist;
-	VectorSet   (planes[ 5].normal,  1, 0, 0);         planes[ 5].dist =  maxs[0];
-	VectorSet   (planes[ 6].normal, -1, 0, 0);         planes[ 6].dist = -mins[0];
-	VectorSet   (planes[ 7].normal, 0,  1, 0);         planes[ 7].dist =  maxs[1];
-	VectorSet   (planes[ 8].normal, 0, -1, 0);         planes[ 8].dist = -mins[1];
-	VectorSet   (planes[ 9].normal, 0, 0,  1);         planes[ 9].dist =  maxs[2];
-	VectorSet   (planes[10].normal, 0, 0, -1);         planes[10].dist = -mins[2];
-
-	// turn the brush into a mesh
-	memset(&mesh, 0, sizeof(rmesh_t));
-	mesh.maxvertices = 256;
-	mesh.vertex3f = vertex3f;
-	mesh.epsilon2 = (1.0f / (32.0f * 32.0f));
-	R_Mesh_AddBrushMeshFromPlanes(&mesh, 11, planes);
-
-	// if that mesh is empty, the light is not visible at all
-	if (!mesh.numvertices)
+	// if we have no points to check, the light is behind the view plane
+	if (!numvertices)
 		return true;
 
-	if (!r_shadow_scissor.integer)
-		return false;
-
-	// if that mesh is not empty, check what area of the screen it covers
+	// if we have some points to transform, check what screen area is covered
 	x1 = y1 = x2 = y2 = 0;
 	v[3] = 1.0f;
-	//Con_Printf("%i vertices to transform...\n", mesh.numvertices);
-	for (i = 0;i < mesh.numvertices;i++)
+	//Con_Printf("%i vertices to transform...\n", numvertices);
+	for (i = 0;i < numvertices;i++)
 	{
-		VectorCopy(mesh.vertex3f + i * 3, v);
-		GL_TransformToScreen(v, v2);
+		VectorCopy(vertex[i], v);
+		R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2);
 		//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]);
 		if (i)
 		{
@@ -1261,40 +2374,60 @@ qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
 
 	// now convert the scissor rectangle to integer screen coordinates
 	ix1 = (int)(x1 - 1.0f);
-	iy1 = (int)(y1 - 1.0f);
+	iy1 = vid.height - (int)(y2 - 1.0f);
 	ix2 = (int)(x2 + 1.0f);
-	iy2 = (int)(y2 + 1.0f);
+	iy2 = vid.height - (int)(y1 + 1.0f);
 	//Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
 
 	// clamp it to the screen
-	if (ix1 < r_view.x) ix1 = r_view.x;
-	if (iy1 < r_view.y) iy1 = r_view.y;
-	if (ix2 > r_view.x + r_view.width) ix2 = r_view.x + r_view.width;
-	if (iy2 > r_view.y + r_view.height) iy2 = r_view.y + r_view.height;
+	if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x;
+	if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y;
+	if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width;
+	if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height;
 
 	// if it is inside out, it's not visible
 	if (ix2 <= ix1 || iy2 <= iy1)
 		return true;
 
 	// the light area is visible, set up the scissor rectangle
-	GL_Scissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
-	//qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);CHECKGLERROR
-	//qglEnable(GL_SCISSOR_TEST);CHECKGLERROR
+	r_shadow_lightscissor[0] = ix1;
+	r_shadow_lightscissor[1] = iy1;
+	r_shadow_lightscissor[2] = ix2 - ix1;
+	r_shadow_lightscissor[3] = iy2 - iy1;
+
+	// D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
+	switch(vid.renderpath)
+	{
+	case RENDERPATH_D3D9:
+	case RENDERPATH_D3D10:
+	case RENDERPATH_D3D11:
+		r_shadow_lightscissor[1] = vid.height - r_shadow_lightscissor[1] - r_shadow_lightscissor[3];
+		break;
+	case RENDERPATH_GL11:
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+		break;
+	}
+
 	r_refdef.stats.lights_scissored++;
 	return false;
 }
 
-static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor)
+static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
 {
-	float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
-	float *normal3f = rsurface.normal3f + 3 * firstvertex;
-	float *color4f = rsurface.array_color4f + 4 * firstvertex;
+	int i;
+	const float *vertex3f;
+	const float *normal3f;
+	float *color4f;
 	float dist, dot, distintensity, shadeintensity, v[3], n[3];
-	if (r_textureunits.integer >= 3)
+	switch (r_shadow_rendermode)
 	{
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
 		if (VectorLength2(diffusecolor) > 0)
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
 			{
 				Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
 				Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
@@ -1308,7 +2441,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 				if (r_refdef.fogenabled)
 				{
 					float f;
-					f = FogPoint_Model(vertex3f);
+					f = RSurf_FogVertex(vertex3f);
 					VectorScale(color4f, f, color4f);
 				}
 				color4f[3] = 1;
@@ -1316,25 +2449,24 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 		}
 		else
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
 			{
 				VectorCopy(ambientcolor, color4f);
 				if (r_refdef.fogenabled)
 				{
 					float f;
 					Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
-					f = FogPoint_Model(vertex3f);
-					VectorScale(color4f, f, color4f);
+					f = RSurf_FogVertex(vertex3f);
+					VectorScale(color4f + 4*i, f, color4f);
 				}
 				color4f[3] = 1;
 			}
 		}
-	}
-	else if (r_textureunits.integer >= 2)
-	{
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
 		if (VectorLength2(diffusecolor) > 0)
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
 			{
 				Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
 				if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
@@ -1356,7 +2488,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 					if (r_refdef.fogenabled)
 					{
 						float f;
-						f = FogPoint_Model(vertex3f);
+						f = RSurf_FogVertex(vertex3f);
 						VectorScale(color4f, f, color4f);
 					}
 				}
@@ -1367,7 +2499,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 		}
 		else
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
 			{
 				Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
 				if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
@@ -1378,7 +2510,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 					if (r_refdef.fogenabled)
 					{
 						float f;
-						f = FogPoint_Model(vertex3f);
+						f = RSurf_FogVertex(vertex3f);
 						VectorScale(color4f, f, color4f);
 					}
 				}
@@ -1387,12 +2519,11 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 				color4f[3] = 1;
 			}
 		}
-	}
-	else
-	{
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
 		if (VectorLength2(diffusecolor) > 0)
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
 			{
 				Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
 				if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
@@ -1415,7 +2546,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 					if (r_refdef.fogenabled)
 					{
 						float f;
-						f = FogPoint_Model(vertex3f);
+						f = RSurf_FogVertex(vertex3f);
 						VectorScale(color4f, f, color4f);
 					}
 				}
@@ -1426,7 +2557,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 		}
 		else
 		{
-			for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
+			for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.array_passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
 			{
 				Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
 				if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
@@ -1438,7 +2569,7 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 					if (r_refdef.fogenabled)
 					{
 						float f;
-						f = FogPoint_Model(vertex3f);
+						f = RSurf_FogVertex(vertex3f);
 						VectorScale(color4f, f, color4f);
 					}
 				}
@@ -1447,686 +2578,32 @@ static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int nu
 				color4f[3] = 1;
 			}
 		}
+		break;
+	default:
+		break;
 	}
 }
 
-// TODO: use glTexGen instead of feeding vertices to texcoordpointer?
-
-static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i)
-{
-	int i;
-	float       *out3f     = rsurface.array_texcoord3f + 3 * firstvertex;
-	const float *vertex3f  = rsurface.vertex3f         + 3 * firstvertex;
-	const float *svector3f = rsurface.svector3f        + 3 * firstvertex;
-	const float *tvector3f = rsurface.tvector3f        + 3 * firstvertex;
-	const float *normal3f  = rsurface.normal3f         + 3 * firstvertex;
-	float lightdir[3];
-	for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
-	{
-		VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir);
-		// the cubemap normalizes this for us
-		out3f[0] = DotProduct(svector3f, lightdir);
-		out3f[1] = DotProduct(tvector3f, lightdir);
-		out3f[2] = DotProduct(normal3f, lightdir);
-	}
-}
-
-static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i)
-{
-	int i;
-	float       *out3f     = rsurface.array_texcoord3f + 3 * firstvertex;
-	const float *vertex3f  = rsurface.vertex3f         + 3 * firstvertex;
-	const float *svector3f = rsurface.svector3f        + 3 * firstvertex;
-	const float *tvector3f = rsurface.tvector3f        + 3 * firstvertex;
-	const float *normal3f  = rsurface.normal3f         + 3 * firstvertex;
-	float lightdir[3], eyedir[3], halfdir[3];
-	for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
-	{
-		VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir);
-		VectorNormalize(lightdir);
-		VectorSubtract(rsurface.modelorg, vertex3f, eyedir);
-		VectorNormalize(eyedir);
-		VectorAdd(lightdir, eyedir, halfdir);
-		// the cubemap normalizes this for us
-		out3f[0] = DotProduct(svector3f, halfdir);
-		out3f[1] = DotProduct(tvector3f, halfdir);
-		out3f[2] = DotProduct(normal3f, halfdir);
-	}
-}
-
-static void R_Shadow_RenderLighting_VisibleLighting(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
+static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
 {
 	// used to display how many times a surface is lit for level design purposes
-	GL_Color(0.1 * r_view.colorscale, 0.025 * r_view.colorscale, 0, 1);
-	R_Mesh_ColorPointer(NULL, 0, 0);
-	R_Mesh_ResetTextureState();
-	R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
+	RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
+	R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
+	RSurf_DrawBatch();
 }
 
-static void R_Shadow_RenderLighting_Light_GLSL(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
+static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
 {
 	// ARB2 GLSL shader path (GFFX5200, Radeon 9500)
-	R_SetupSurfaceShader(lightcolorbase, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT);
-	R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
-	R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
-	R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
-	R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
-	R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap));
-	R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
-	R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
-	R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
-	R_Mesh_TexBind(10, R_GetTexture(r_shadow_attenuationgradienttexture));
-	R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
-	R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
-	R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
-	R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
+	R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL);
 	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-	{
-		qglDepthFunc(GL_EQUAL);CHECKGLERROR
-	}
-	R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
+		GL_DepthFunc(GL_EQUAL);
+	RSurf_DrawBatch();
 	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-	{
-		qglDepthFunc(GL_LEQUAL);CHECKGLERROR
-	}
-}
-
-static void R_Shadow_RenderLighting_Light_Dot3_Finalize(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, float r, float g, float b)
-{
-	// shared final code for all the dot3 layers
-	int renders;
-	GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 0);
-	for (renders = 0;renders < 64 && (r > 0 || g > 0 || b > 0);renders++, r--, g--, b--)
-	{
-		GL_Color(bound(0, r, 1), bound(0, g, 1), bound(0, b, 1), 1);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-	}
-}
-
-static void R_Shadow_RenderLighting_Light_Dot3_AmbientPass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *basetexture, float colorscale)
-{
-	rmeshstate_t m;
-	// colorscale accounts for how much we multiply the brightness
-	// during combine.
-	//
-	// mult is how many times the final pass of the lighting will be
-	// performed to get more brightness than otherwise possible.
-	//
-	// Limit mult to 64 for sanity sake.
-	GL_Color(1,1,1,1);
-	if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap != r_texture_whitecube && r_textureunits.integer >= 4)
-	{
-		// 3 3D combine path (Geforce3, Radeon 8500)
-		memset(&m, 0, sizeof(m));
-		m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(basetexture);
-		m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[1] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[2] = R_GetTexture(rsurface.rtlight->currentcubemap);
-		m.pointer_texcoord3f[2] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[2] = rsurface.entitytolight;
-		GL_BlendFunc(GL_ONE, GL_ONE);
-	}
-	else if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap == r_texture_whitecube && r_textureunits.integer >= 2)
-	{
-		// 2 3D combine path (Geforce3, original Radeon)
-		memset(&m, 0, sizeof(m));
-		m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(basetexture);
-		m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[1] = rsurface.texture->currenttexmatrix;
-		GL_BlendFunc(GL_ONE, GL_ONE);
-	}
-	else if (r_textureunits.integer >= 4 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
-	{
-		// 4 2D combine path (Geforce3, Radeon 8500)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationz;
-		m.tex[2] = R_GetTexture(basetexture);
-		m.pointer_texcoord[2] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[2] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[3] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[3] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[3] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_ONE, GL_ONE);
-	}
-	else if (r_textureunits.integer >= 3 && rsurface.rtlight->currentcubemap == r_texture_whitecube)
-	{
-		// 3 2D combine path (Geforce3, original Radeon)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationz;
-		m.tex[2] = R_GetTexture(basetexture);
-		m.pointer_texcoord[2] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[2] = rsurface.texture->currenttexmatrix;
-		GL_BlendFunc(GL_ONE, GL_ONE);
-	}
-	else
-	{
-		// 2/2/2 2D combine path (any dot3 card)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationz;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	// this final code is shared
-	R_Mesh_TextureState(&m);
-	R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
-}
-
-static void R_Shadow_RenderLighting_Light_Dot3_DiffusePass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *basetexture, rtexture_t *normalmaptexture, float colorscale)
-{
-	rmeshstate_t m;
-	// colorscale accounts for how much we multiply the brightness
-	// during combine.
-	//
-	// mult is how many times the final pass of the lighting will be
-	// performed to get more brightness than otherwise possible.
-	//
-	// Limit mult to 64 for sanity sake.
-	GL_Color(1,1,1,1);
-	// generate normalization cubemap texcoords
-	R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i);
-	if (r_shadow_texture3d.integer && r_textureunits.integer >= 4)
-	{
-		// 3/2 3D combine path (Geforce3, Radeon 8500)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.texcombinergb[0] = GL_REPLACE;
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[2] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[2] = rsurface.entitytoattenuationxyz;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
-	{
-		// 1/2/2 3D combine path (original Radeon)
-		memset(&m, 0, sizeof(m));
-		m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.texcombinergb[0] = GL_REPLACE;
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube)
-	{
-		// 2/2 3D combine path (original Radeon)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.texcombinergb[0] = GL_REPLACE;
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationxyz;
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else if (r_textureunits.integer >= 4)
-	{
-		// 4/2 2D combine path (Geforce3, Radeon 8500)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.texcombinergb[0] = GL_REPLACE;
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[2] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[2] = rsurface.entitytoattenuationxyz;
-		m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[3] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[3] = rsurface.entitytoattenuationz;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else
-	{
-		// 2/2/2 2D combine path (any dot3 card)
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationz;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.texcombinergb[0] = GL_REPLACE;
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(basetexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	// this final code is shared
-	R_Mesh_TextureState(&m);
-	R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
-}
-
-static void R_Shadow_RenderLighting_Light_Dot3_SpecularPass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *glosstexture, rtexture_t *normalmaptexture, float colorscale)
-{
-	float glossexponent;
-	rmeshstate_t m;
-	// FIXME: detect blendsquare!
-	//if (!gl_support_blendsquare)
-	//	return;
-	GL_Color(1,1,1,1);
-	// generate normalization cubemap texcoords
-	R_Shadow_GenTexCoords_Specular_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i);
-	if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
-	{
-		// 2/0/0/1/2 3D combine blendsquare path
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		// this squares the result
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second and third pass
-		R_Mesh_ResetTextureState();
-		// square alpha in framebuffer a few times to make it shiny
-		GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
-		for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
-			R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// fourth pass
-		memset(&m, 0, sizeof(m));
-		m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		R_Mesh_TextureState(&m);
-		GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// fifth pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(glosstexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare!
-	{
-		// 2/0/0/2 3D combine blendsquare path
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		// this squares the result
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second and third pass
-		R_Mesh_ResetTextureState();
-		// square alpha in framebuffer a few times to make it shiny
-		GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
-		for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
-			R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// fourth pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(glosstexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationxyz;
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	else
-	{
-		// 2/0/0/2/2 2D combine blendsquare path
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(normalmaptexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
-		m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
-		m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
-		m.pointer_texcoord_bufferobject[1] = 0;
-		m.pointer_texcoord_bufferoffset[1] = 0;
-		R_Mesh_TextureState(&m);
-		GL_ColorMask(0,0,0,1);
-		// this squares the result
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// second and third pass
-		R_Mesh_ResetTextureState();
-		// square alpha in framebuffer a few times to make it shiny
-		GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
-		for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
-			R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// fourth pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[0] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[0] = rsurface.entitytoattenuationxyz;
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		m.texmatrix[1] = rsurface.entitytoattenuationz;
-		R_Mesh_TextureState(&m);
-		GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
-		R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-
-		// fifth pass
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(glosstexture);
-		m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-		m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-		m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
-		{
-			m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
-			m.pointer_texcoord3f[1] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-			m.texmatrix[1] = rsurface.entitytolight;
-		}
-		GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-	}
-	// this final code is shared
-	R_Mesh_TextureState(&m);
-	R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
+		GL_DepthFunc(GL_LEQUAL);
 }
 
-static void R_Shadow_RenderLighting_Light_Dot3(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
-{
-	// ARB path (any Geforce, any Radeon)
-	qboolean doambient = ambientscale > 0;
-	qboolean dodiffuse = diffusescale > 0;
-	qboolean dospecular = specularscale > 0;
-	if (!doambient && !dodiffuse && !dospecular)
-		return;
-	R_Mesh_ColorPointer(NULL, 0, 0);
-	if (doambient)
-		R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, basetexture, ambientscale * r_view.colorscale);
-	if (dodiffuse)
-		R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, basetexture, normalmaptexture, diffusescale * r_view.colorscale);
-	if (dopants)
-	{
-		if (doambient)
-			R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorpants, pantstexture, ambientscale * r_view.colorscale);
-		if (dodiffuse)
-			R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorpants, pantstexture, normalmaptexture, diffusescale * r_view.colorscale);
-	}
-	if (doshirt)
-	{
-		if (doambient)
-			R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorshirt, shirttexture, ambientscale * r_view.colorscale);
-		if (dodiffuse)
-			R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorshirt, shirttexture, normalmaptexture, diffusescale * r_view.colorscale);
-	}
-	if (dospecular)
-		R_Shadow_RenderLighting_Light_Dot3_SpecularPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, glosstexture, normalmaptexture, specularscale * r_view.colorscale);
-}
-
-void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, vec3_t diffusecolor2, vec3_t ambientcolor2)
+static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
 {
 	int renders;
 	int i;
@@ -2137,9 +2614,10 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 	int *newe;
 	const int *e;
 	float *c;
-	int newelements[4096*3];
-	R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2);
-	for (renders = 0;renders < 64;renders++)
+	int maxtriangles = 4096;
+	static int newelements[4096*3];
+	R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
+	for (renders = 0;renders < 4;renders++)
 	{
 		stop = true;
 		newfirstvertex = 0;
@@ -2153,7 +2631,7 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 		// renders them at once
 		for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
 		{
-			if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01)
+			if (VectorLength2(rsurface.array_passcolor4f + e[0] * 4) + VectorLength2(rsurface.array_passcolor4f + e[1] * 4) + VectorLength2(rsurface.array_passcolor4f + e[2] * 4) >= 0.01)
 			{
 				if (newnumtriangles)
 				{
@@ -2174,9 +2652,9 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 				newe[2] = e[2];
 				newnumtriangles++;
 				newe += 3;
-				if (newnumtriangles >= (int)(sizeof(newelements)/sizeof(float[3])))
+				if (newnumtriangles >= maxtriangles)
 				{
-					R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, newnumtriangles, newelements, 0, 0);
+					R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
 					newnumtriangles = 0;
 					newe = newelements;
 					stop = false;
@@ -2185,11 +2663,7 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 		}
 		if (newnumtriangles >= 1)
 		{
-			// if all triangles are included, use the original array to take advantage of the bufferobject if possible
-			if (newnumtriangles == numtriangles)
-				R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset);
-			else
-				R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, newnumtriangles, newelements, 0, 0);
+			R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
 			stop = false;
 		}
 		// if we couldn't find any lit triangles, exit early
@@ -2200,7 +2674,7 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 		// handling of negative colors
 		// (some old drivers even have improper handling of >1 color)
 		stop = true;
-		for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4)
+		for (i = 0, c = rsurface.array_passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
 		{
 			if (c[0] > 1 || c[1] > 1 || c[2] > 1)
 			{
@@ -2218,70 +2692,81 @@ void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices,
 	}
 }
 
-static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
+static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
 {
 	// OpenGL 1.1 path (anything)
 	float ambientcolorbase[3], diffusecolorbase[3];
 	float ambientcolorpants[3], diffusecolorpants[3];
 	float ambientcolorshirt[3], diffusecolorshirt[3];
-	rmeshstate_t m;
-	VectorScale(lightcolorbase, ambientscale * 2 * r_view.colorscale, ambientcolorbase);
-	VectorScale(lightcolorbase, diffusescale * 2 * r_view.colorscale, diffusecolorbase);
-	VectorScale(lightcolorpants, ambientscale * 2 * r_view.colorscale, ambientcolorpants);
-	VectorScale(lightcolorpants, diffusescale * 2 * r_view.colorscale, diffusecolorpants);
-	VectorScale(lightcolorshirt, ambientscale * 2 * r_view.colorscale, ambientcolorshirt);
-	VectorScale(lightcolorshirt, diffusescale * 2 * r_view.colorscale, diffusecolorshirt);
-	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-	R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
-	memset(&m, 0, sizeof(m));
-	m.tex[0] = R_GetTexture(basetexture);
-	m.texmatrix[0] = rsurface.texture->currenttexmatrix;
-	m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
-	m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
-	m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
-	if (r_textureunits.integer >= 2)
-	{
-		// voodoo2 or TNT
-		m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
-		m.texmatrix[1] = rsurface.entitytoattenuationxyz;
-		m.pointer_texcoord3f[1] = rsurface.vertex3f;
-		m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
-		m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
-		if (r_textureunits.integer >= 3)
-		{
-			// Voodoo4 or Kyro (or Geforce3/Radeon with gl_combine off)
-			m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
-			m.texmatrix[2] = rsurface.entitytoattenuationz;
-			m.pointer_texcoord3f[2] = rsurface.vertex3f;
-			m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
-			m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
-		}
-	}
-	R_Mesh_TextureState(&m);
-	//R_Mesh_TexBind(0, R_GetTexture(basetexture));
-	R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorbase, ambientcolorbase);
+	const float *surfacecolor = rsurface.texture->dlightcolor;
+	const float *surfacepants = rsurface.colormap_pantscolor;
+	const float *surfaceshirt = rsurface.colormap_shirtcolor;
+	rtexture_t *basetexture = rsurface.texture->basetexture;
+	rtexture_t *pantstexture = rsurface.texture->pantstexture;
+	rtexture_t *shirttexture = rsurface.texture->shirttexture;
+	qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
+	qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
+	ambientscale *= 2 * r_refdef.view.colorscale;
+	diffusescale *= 2 * r_refdef.view.colorscale;
+	ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
+	diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
+	ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
+	diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
+	ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
+	diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
+	RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD, texturenumsurfaces, texturesurfacelist);
+	R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
+	R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.array_passcolor4f, 0, 0);
+	R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
+	R_Mesh_TexBind(0, basetexture);
+	R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
+	R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
+	switch(r_shadow_rendermode)
+	{
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
+		R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
+		R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
+		R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
+		R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
+		R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
+		R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
+		R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
+		R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
+		// fall through
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
+		R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
+		R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
+		R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
+		R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
+		break;
+	default:
+		break;
+	}
+	//R_Mesh_TexBind(0, basetexture);
+	R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
 	if (dopants)
 	{
-		R_Mesh_TexBind(0, R_GetTexture(pantstexture));
-		R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorpants, ambientcolorpants);
+		R_Mesh_TexBind(0, pantstexture);
+		R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
 	}
 	if (doshirt)
 	{
-		R_Mesh_TexBind(0, R_GetTexture(shirttexture));
-		R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorshirt, ambientcolorshirt);
+		R_Mesh_TexBind(0, shirttexture);
+		R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
 	}
 }
 
 extern cvar_t gl_lightmaps;
-void R_Shadow_RenderLighting(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset)
+void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
 {
 	float ambientscale, diffusescale, specularscale;
-	vec3_t lightcolorbase, lightcolorpants, lightcolorshirt;
-	rtexture_t *nmap;
-	// calculate colors to render this texture with
-	lightcolorbase[0] = rsurface.rtlight->currentcolor[0] * rsurface.texture->dlightcolor[0];
-	lightcolorbase[1] = rsurface.rtlight->currentcolor[1] * rsurface.texture->dlightcolor[1];
-	lightcolorbase[2] = rsurface.rtlight->currentcolor[2] * rsurface.texture->dlightcolor[2];
+	qboolean negated;
+	float lightcolor[3];
+	VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
 	ambientscale = rsurface.rtlight->ambientscale;
 	diffusescale = rsurface.rtlight->diffusescale;
 	specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
@@ -2290,81 +2775,80 @@ void R_Shadow_RenderLighting(int firstvertex, int numvertices, int numtriangles,
 		ambientscale += 1.0f * diffusescale;
 		diffusescale = 0;
 		specularscale = 0;
-	}
-	if ((ambientscale + diffusescale) * VectorLength2(lightcolorbase) + specularscale * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f))
-		return;
-	GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
-	GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
-	GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
-	GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
-	nmap = rsurface.texture->currentskinframe->nmap;
-	if (gl_lightmaps.integer)
-		nmap = r_texture_blanknormalmap;
-	if (rsurface.texture->colormapping && !gl_lightmaps.integer)
-	{
-		qboolean dopants = rsurface.texture->currentskinframe->pants != NULL && VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f);
-		qboolean doshirt = rsurface.texture->currentskinframe->shirt != NULL && VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
-		if (dopants)
-		{
-			lightcolorpants[0] = lightcolorbase[0] * rsurface.colormap_pantscolor[0];
-			lightcolorpants[1] = lightcolorbase[1] * rsurface.colormap_pantscolor[1];
-			lightcolorpants[2] = lightcolorbase[2] * rsurface.colormap_pantscolor[2];
-		}
-		else
-			VectorClear(lightcolorpants);
-		if (doshirt)
-		{
-			lightcolorshirt[0] = lightcolorbase[0] * rsurface.colormap_shirtcolor[0];
-			lightcolorshirt[1] = lightcolorbase[1] * rsurface.colormap_shirtcolor[1];
-			lightcolorshirt[2] = lightcolorbase[2] * rsurface.colormap_shirtcolor[2];
-		}
-		else
-			VectorClear(lightcolorshirt);
-		switch (r_shadow_rendermode)
+	}
+	if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
+		return;
+	negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
+	if(negated)
+	{
+		VectorNegate(lightcolor, lightcolor);
+		switch(vid.renderpath)
 		{
-		case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
-			GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
-			R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
-			break;
-		case R_SHADOW_RENDERMODE_LIGHT_GLSL:
-			R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
+		case RENDERPATH_GL11:
+		case RENDERPATH_GL13:
+		case RENDERPATH_GL20:
+		case RENDERPATH_CGGL:
+			qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
 			break;
-		case R_SHADOW_RENDERMODE_LIGHT_DOT3:
-			R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
+		case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+			IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
+#endif
 			break;
-		case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
-			R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
+		case RENDERPATH_D3D10:
+			Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 			break;
-		default:
-			Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
+		case RENDERPATH_D3D11:
+			Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 			break;
 		}
 	}
-	else
-	{
-		switch (r_shadow_rendermode)
+	RSurf_SetupDepthAndCulling();
+	switch (r_shadow_rendermode)
+	{
+	case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
+		GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
+		R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_GLSL:
+		R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
+		break;
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
+	case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
+		R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
+		break;
+	default:
+		Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
+		break;
+	}
+	if(negated)
+	{
+		switch(vid.renderpath)
 		{
-		case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
-			GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
-			R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
+		case RENDERPATH_GL11:
+		case RENDERPATH_GL13:
+		case RENDERPATH_GL20:
+		case RENDERPATH_CGGL:
+			qglBlendEquationEXT(GL_FUNC_ADD_EXT);
 			break;
-		case R_SHADOW_RENDERMODE_LIGHT_GLSL:
-			R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
-			break;
-		case R_SHADOW_RENDERMODE_LIGHT_DOT3:
-			R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
+		case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+			IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
+#endif
 			break;
-		case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
-			R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
+		case RENDERPATH_D3D10:
+			Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 			break;
-		default:
-			Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
+		case RENDERPATH_D3D11:
+			Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 			break;
 		}
 	}
 }
 
-void R_RTLight_Update(rtlight_t *rtlight, int isstatic, matrix4x4_t *matrix, vec3_t color, int style, const char *cubemapname, qboolean shadow, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)
+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)
 {
 	matrix4x4_t tempmatrix = *matrix;
 	Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
@@ -2411,19 +2895,23 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 {
 	int i;
 	int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
-	int lighttris, shadowtris, shadowmeshes, shadowmeshtris;
-	entity_render_t *ent = r_refdef.worldentity;
-	model_t *model = r_refdef.worldmodel;
+	int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
+	entity_render_t *ent = r_refdef.scene.worldentity;
+	dp_model_t *model = r_refdef.scene.worldmodel;
 	unsigned char *data;
+	shadowmesh_t *mesh;
 
 	// compile the light
 	rtlight->compiled = true;
+	rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
 	rtlight->static_numleafs = 0;
 	rtlight->static_numleafpvsbytes = 0;
 	rtlight->static_leaflist = NULL;
 	rtlight->static_leafpvs = NULL;
 	rtlight->static_numsurfaces = 0;
 	rtlight->static_surfacelist = NULL;
+	rtlight->static_shadowmap_receivers = 0x3F;
+	rtlight->static_shadowmap_casters = 0x3F;
 	rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
 	rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
 	rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
@@ -2433,10 +2921,9 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 
 	if (model && model->GetLightInfo)
 	{
-		// this variable must be set for the CompileShadowVolume code
+		// this variable must be set for the CompileShadowVolume/CompileShadowMap code
 		r_shadow_compilingrtlight = rtlight;
-		R_Shadow_EnlargeLeafSurfaceTrisBuffer(model->brush.num_leafs, model->num_surfaces, model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles, model->surfmesh.num_triangles);
-		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);
+		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);
 		numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
 		numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
 		numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
@@ -2461,8 +2948,17 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 			memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
 		if (rtlight->static_numlighttrispvsbytes)
 			memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
-		if (model->CompileShadowVolume && rtlight->shadow)
-			model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
+		switch (rtlight->shadowmode)
+		{
+		case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+			if (model->CompileShadowMap && rtlight->shadow)
+				model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
+			break;
+		default:
+			if (model->CompileShadowVolume && rtlight->shadow)
+				model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
+			break;
+		}
 		// now we're done compiling the rtlight
 		r_shadow_compilingrtlight = NULL;
 	}
@@ -2472,17 +2968,15 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 	//rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
 	//rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
 
-	shadowmeshes = 0;
-	shadowmeshtris = 0;
-	if (rtlight->static_meshchain_shadow)
-	{
-		shadowmesh_t *mesh;
-		for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
-		{
-			shadowmeshes++;
-			shadowmeshtris += mesh->numtriangles;
-		}
-	}
+	shadowzpasstris = 0;
+	if (rtlight->static_meshchain_shadow_zpass)
+		for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
+			shadowzpasstris += mesh->numtriangles;
+
+	shadowzfailtris = 0;
+	if (rtlight->static_meshchain_shadow_zfail)
+		for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
+			shadowzfailtris += mesh->numtriangles;
 
 	lighttris = 0;
 	if (rtlight->static_numlighttrispvsbytes)
@@ -2496,17 +2990,23 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 			if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
 				shadowtris++;
 
-	if (developer.integer >= 10)
-		Con_Printf("static light built: %f %f %f : %f %f %f box, %i light triangles, %i shadow triangles, %i compiled shadow volume triangles (in %i meshes)\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], lighttris, shadowtris, shadowmeshtris, shadowmeshes);
+	if (developer_extra.integer)
+		Con_DPrintf("static light built: %f %f %f : %f %f %f box, %i light triangles, %i shadow triangles, %i zpass/%i zfail compiled shadow volume triangles\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], lighttris, shadowtris, shadowzpasstris, shadowzfailtris);
 }
 
 void R_RTLight_Uncompile(rtlight_t *rtlight)
 {
 	if (rtlight->compiled)
 	{
-		if (rtlight->static_meshchain_shadow)
-			Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow);
-		rtlight->static_meshchain_shadow = NULL;
+		if (rtlight->static_meshchain_shadow_zpass)
+			Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
+		rtlight->static_meshchain_shadow_zpass = NULL;
+		if (rtlight->static_meshchain_shadow_zfail)
+			Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
+		rtlight->static_meshchain_shadow_zfail = NULL;
+		if (rtlight->static_meshchain_shadow_shadowmap)
+			Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
+		rtlight->static_meshchain_shadow_shadowmap = NULL;
 		// these allocations are grouped
 		if (rtlight->static_surfacelist)
 			Mem_Free(rtlight->static_surfacelist);
@@ -2528,9 +3028,10 @@ void R_Shadow_UncompileWorldLights(void)
 {
 	size_t lightindex;
 	dlight_t *light;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
 		R_RTLight_Uncompile(&light->rtlight);
@@ -2542,20 +3043,20 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 	int i, j;
 	mplane_t plane;
 	// reset the count of frustum planes
-	// see rsurface.rtlight_frustumplanes definition for how much this array
+	// see rtlight->cached_frustumplanes definition for how much this array
 	// can hold
-	rsurface.rtlight_numfrustumplanes = 0;
+	rtlight->cached_numfrustumplanes = 0;
 
 	// haven't implemented a culling path for ortho rendering
-	if (!r_view.useperspective)
+	if (!r_refdef.view.useperspective)
 	{
 		// check if the light is on screen and copy the 4 planes if it is
 		for (i = 0;i < 4;i++)
-			if (PlaneDiff(rtlight->shadoworigin, &r_view.frustum[i]) < -0.03125)
+			if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
 				break;
 		if (i == 4)
 			for (i = 0;i < 4;i++)
-				rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = r_view.frustum[i];
+				rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
 		return;
 	}
 
@@ -2574,14 +3075,14 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 	{
 		// quickly reject standard frustum planes that put the light
 		// origin outside the frustum
-		if (PlaneDiff(rtlight->shadoworigin, &r_view.frustum[i]) < -0.03125)
+		if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
 			continue;
 		// copy the plane
-		rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = r_view.frustum[i];
+		rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
 	}
 	// if all the standard frustum planes were accepted, the light is onscreen
 	// otherwise we need to generate some more planes below...
-	if (rsurface.rtlight_numfrustumplanes < 4)
+	if (rtlight->cached_numfrustumplanes < 4)
 	{
 		// at least one of the stock frustum planes failed, so we need to
 		// create one or two custom planes to enclose the light origin
@@ -2589,12 +3090,12 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 		{
 			// create a plane using the view origin and light origin, and a
 			// single point from the frustum corner set
-			TriangleNormal(r_view.origin, r_view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
+			TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
 			VectorNormalize(plane.normal);
-			plane.dist = DotProduct(r_view.origin, plane.normal);
+			plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
 			// see if this plane is backwards and flip it if so
 			for (j = 0;j < 4;j++)
-				if (j != i && DotProduct(r_view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
+				if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
 					break;
 			if (j < 4)
 			{
@@ -2602,7 +3103,7 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 				plane.dist *= -1;
 				// flipped plane, test again to see if it is now valid
 				for (j = 0;j < 4;j++)
-					if (j != i && DotProduct(r_view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
+					if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
 						break;
 				// if the plane is still not valid, then it is dividing the
 				// frustum and has to be rejected
@@ -2612,12 +3113,12 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 			// we have created a valid plane, compute extra info
 			PlaneClassify(&plane);
 			// copy the plane
-			rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
+			rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
 #if 1
 			// if we've found 5 frustum planes then we have constructed a
 			// proper split-side case and do not need to keep searching for
 			// planes to enclose the light origin
-			if (rsurface.rtlight_numfrustumplanes == 5)
+			if (rtlight->cached_numfrustumplanes == 5)
 				break;
 #endif
 		}
@@ -2625,10 +3126,10 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 #endif
 
 #if 0
-	for (i = 0;i < rsurface.rtlight_numfrustumplanes;i++)
+	for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
 	{
-		plane = rsurface.rtlight_frustumplanes[i];
-		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_view.frustumcorner[0], &plane), PlaneDiff(r_view.frustumcorner[1], &plane), PlaneDiff(r_view.frustumcorner[2], &plane), PlaneDiff(r_view.frustumcorner[3], &plane), PlaneDiff(rtlight->shadoworigin, &plane));
+		plane = rtlight->cached_frustumplanes[i];
+		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));
 	}
 #endif
 
@@ -2647,7 +3148,7 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 			VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
 			plane.dist = VectorNormalizeLength(plane.normal);
 			plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
-			rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
+			rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
 		}
 	}
 #endif
@@ -2658,8 +3159,8 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 	{
 		VectorClear(plane.normal);
 		plane.normal[i >> 1] = (i & 1) ? -1 : 1;
-		plane.dist = (i & 1) ? -rsurface.rtlight_cullmaxs[i >> 1] : rsurface.rtlight_cullmins[i >> 1];
-		rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
+		plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
+		rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
 	}
 #endif
 
@@ -2670,91 +3171,139 @@ void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
 	vec_t bestdist;
 	// reduce all plane distances to tightly fit the rtlight cull box, which
 	// is in worldspace
-	VectorSet(points[0], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]);
-	VectorSet(points[1], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]);
-	VectorSet(points[2], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]);
-	VectorSet(points[3], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]);
-	VectorSet(points[4], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]);
-	VectorSet(points[5], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]);
-	VectorSet(points[6], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]);
-	VectorSet(points[7], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]);
-	oldnum = rsurface.rtlight_numfrustumplanes;
-	rsurface.rtlight_numfrustumplanes = 0;
+	VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
+	VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
+	VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
+	VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
+	VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
+	VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
+	VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
+	VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
+	oldnum = rtlight->cached_numfrustumplanes;
+	rtlight->cached_numfrustumplanes = 0;
 	for (j = 0;j < oldnum;j++)
 	{
 		// find the nearest point on the box to this plane
-		bestdist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[0]);
+		bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
 		for (i = 1;i < 8;i++)
 		{
-			dist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[i]);
+			dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
 			if (bestdist > dist)
 				bestdist = dist;
 		}
-		Con_Printf("light %p %splane #%i %f %f %f : %f < %f\n", rtlight, rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125 ? "^2" : "^1", j, rsurface.rtlight_frustumplanes[j].normal[0], rsurface.rtlight_frustumplanes[j].normal[1], rsurface.rtlight_frustumplanes[j].normal[2], rsurface.rtlight_frustumplanes[j].dist, bestdist);
+		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);
 		// if the nearest point is near or behind the plane, we want this
 		// plane, otherwise the plane is useless as it won't cull anything
-		if (rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125)
+		if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
 		{
-			PlaneClassify(&rsurface.rtlight_frustumplanes[j]);
-			rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = rsurface.rtlight_frustumplanes[j];
+			PlaneClassify(&rtlight->cached_frustumplanes[j]);
+			rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
 		}
 	}
 	}
 #endif
 }
 
-void R_Shadow_DrawWorldShadow(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
+void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
+{
+	shadowmesh_t *mesh;
+
+	RSurf_ActiveWorldEntity();
+
+	if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
+	{
+		CHECKGLERROR
+		GL_CullFace(GL_NONE);
+        mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
+        for (;mesh;mesh = mesh->next)
+        {
+			if (!mesh->sidetotals[r_shadow_shadowmapside])
+				continue;
+            r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
+            R_Mesh_PrepareVertices_Position(mesh->numverts, mesh->vertexposition, mesh->vertexpositionbuffer);
+            R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
+        }
+        CHECKGLERROR
+    }
+	else if (r_refdef.scene.worldentity->model)
+		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);
+
+	rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+}
+
+void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
 {
+	qboolean zpass = false;
+	shadowmesh_t *mesh;
+	int t, tend;
+	int surfacelistindex;
+	msurface_t *surface;
+
 	RSurf_ActiveWorldEntity();
+
 	if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
 	{
-		shadowmesh_t *mesh;
 		CHECKGLERROR
-		for (mesh = rsurface.rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
+		if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
+		{
+			zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
+			R_Shadow_RenderMode_StencilShadowVolumes(zpass);
+		}
+		mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
+		for (;mesh;mesh = mesh->next)
 		{
 			r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
-			R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
-			GL_LockArrays(0, mesh->numverts);
-			if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL)
+			R_Mesh_PrepareVertices_Position(mesh->numverts, mesh->vertexposition, mesh->vertexpositionbuffer);
+			if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
+			{
+				// increment stencil if frontface is infront of depthbuffer
+				GL_CullFace(r_refdef.view.cullface_back);
+				R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
+				R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
+				// decrement stencil if backface is infront of depthbuffer
+				GL_CullFace(r_refdef.view.cullface_front);
+				R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
+			}
+			else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
 			{
 				// decrement stencil if backface is behind depthbuffer
-				GL_CullFace(r_view.cullface_front);
-				qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
-				R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->ebo, 0);
+				GL_CullFace(r_refdef.view.cullface_front);
+				R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
+				R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
 				// increment stencil if frontface is behind depthbuffer
-				GL_CullFace(r_view.cullface_back);
-				qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
+				GL_CullFace(r_refdef.view.cullface_back);
+				R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
 			}
-			R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->ebo, 0);
-			GL_LockArrays(0, 0);
+			R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
 		}
 		CHECKGLERROR
 	}
-	else if (numsurfaces && r_refdef.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer)
+	else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
 	{
-		int t, tend;
-		int surfacelistindex;
-		msurface_t *surface;
-		R_Shadow_PrepareShadowMark(r_refdef.worldmodel->brush.shadowmesh->numtriangles);
+		// use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
+		R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
 		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
-			surface = r_refdef.worldmodel->data_surfaces + surfacelist[surfacelistindex];
+			surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
 			for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
 				if (CHECKPVSBIT(trispvs, t))
 					shadowmarklist[numshadowmark++] = t;
 		}
-		R_Shadow_VolumeFromList(r_refdef.worldmodel->brush.shadowmesh->numverts, r_refdef.worldmodel->brush.shadowmesh->numtriangles, r_refdef.worldmodel->brush.shadowmesh->vertex3f, r_refdef.worldmodel->brush.shadowmesh->element3i, r_refdef.worldmodel->brush.shadowmesh->neighbor3i, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius + r_refdef.worldmodel->radius*2 + r_shadow_projectdistance.value, numshadowmark, shadowmarklist);
+		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);
 	}
 	else if (numsurfaces)
-		r_refdef.worldmodel->DrawShadowVolume(r_refdef.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs);
+		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);
+
+	rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
 }
 
 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
 {
 	vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
 	vec_t relativeshadowradius;
-	RSurf_ActiveModelEntity(ent, false, false);
+	RSurf_ActiveModelEntity(ent, false, false, false);
 	Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
+	// we need to re-init the shader for each entity because the matrix changed
 	relativeshadowradius = rsurface.rtlight->radius / ent->scale;
 	relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
 	relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
@@ -2762,81 +3311,102 @@ void R_Shadow_DrawEntityShadow(entity_render_t *ent)
 	relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
 	relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
 	relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
-	ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->surfacelist, relativeshadowmins, relativeshadowmaxs);
+	switch (r_shadow_rendermode)
+	{
+	case R_SHADOW_RENDERMODE_SHADOWMAP2D:
+		ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
+		break;
+	default:
+		ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
+		break;
+	}
+	rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
 }
 
 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
 {
 	// set up properties for rendering light onto this entity
-	RSurf_ActiveModelEntity(ent, true, true);
+	RSurf_ActiveModelEntity(ent, true, true, false);
+	GL_AlphaTest(false);
 	Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
 	Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
 	Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
 	Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
-	if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
-		R_Mesh_TexMatrix(3, &rsurface.entitytolight);
 }
 
-void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
+void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
 {
-	if (!r_refdef.worldmodel->DrawLight)
+	if (!r_refdef.scene.worldmodel->DrawLight)
 		return;
 
 	// set up properties for rendering light onto this entity
 	RSurf_ActiveWorldEntity();
+	GL_AlphaTest(false);
 	rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
 	Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
 	Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
 	VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
-	if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
-		R_Mesh_TexMatrix(3, &rsurface.entitytolight);
 
-	r_refdef.worldmodel->DrawLight(r_refdef.worldentity, numsurfaces, surfacelist, trispvs);
+	r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
+
+	rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
 }
 
-void R_Shadow_DrawEntityLight(entity_render_t *ent, int numsurfaces, int *surfacelist)
+void R_Shadow_DrawEntityLight(entity_render_t *ent)
 {
-	model_t *model = ent->model;
+	dp_model_t *model = ent->model;
 	if (!model->DrawLight)
 		return;
 
 	R_Shadow_SetupEntityLight(ent);
 
-	model->DrawLight(ent, model->nummodelsurfaces, model->surfacelist, NULL);
+	model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
+
+	rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
 }
 
-void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
+void R_Shadow_PrepareLight(rtlight_t *rtlight)
 {
 	int i;
 	float f;
 	int numleafs, numsurfaces;
 	int *leaflist, *surfacelist;
-	unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs;
+	unsigned char *leafpvs;
+	unsigned char *shadowtrispvs;
+	unsigned char *lighttrispvs;
+	//unsigned char *surfacesides;
 	int numlightentities;
 	int numlightentities_noselfshadow;
 	int numshadowentities;
 	int numshadowentities_noselfshadow;
-	entity_render_t *lightentities[MAX_EDICTS];
-	entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
-	entity_render_t *shadowentities[MAX_EDICTS];
-	entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
+	static entity_render_t *lightentities[MAX_EDICTS];
+	static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
+	static entity_render_t *shadowentities[MAX_EDICTS];
+	static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
+	qboolean nolight;
+
+	rtlight->draw = false;
 
 	// skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
 	// skip lights that are basically invisible (color 0 0 0)
-	if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
-		return;
+	nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
 
 	// loading is done before visibility checks because loading should happen
 	// all at once at the start of a level, not when it stalls gameplay.
 	// (especially important to benchmarks)
 	// compile light
-	if (rtlight->isstatic && !rtlight->compiled && r_shadow_realtime_world_compile.integer)
+	if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
+	{
+		if (rtlight->compiled)
+			R_RTLight_Uncompile(rtlight);
 		R_RTLight_Compile(rtlight);
+	}
+
 	// load cubemap
-	rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
+	rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
 
 	// look up the light style value at this time
-	f = (rtlight->style >= 0 ? r_refdef.lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value;
+	f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
 	VectorScale(rtlight->color, f, rtlight->currentcolor);
 	/*
 	if (rtlight->selected)
@@ -2850,12 +3420,18 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
 	if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
 		return;
 
+	// skip processing on corona-only lights
+	if (nolight)
+		return;
+
 	// if the light box is offscreen, skip it
 	if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
 		return;
 
-	VectorCopy(rtlight->cullmins, rsurface.rtlight_cullmins);
-	VectorCopy(rtlight->cullmaxs, rsurface.rtlight_cullmaxs);
+	VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
+	VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
+
+	R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
 
 	if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
 	{
@@ -2866,22 +3442,24 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
 		leafpvs = rtlight->static_leafpvs;
 		numsurfaces = rtlight->static_numsurfaces;
 		surfacelist = rtlight->static_surfacelist;
+		//surfacesides = NULL;
 		shadowtrispvs = rtlight->static_shadowtrispvs;
 		lighttrispvs = rtlight->static_lighttrispvs;
 	}
-	else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo)
+	else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
 	{
 		// dynamic light, world available and can receive realtime lighting
 		// calculate lit surfaces and leafs
-		R_Shadow_EnlargeLeafSurfaceTrisBuffer(r_refdef.worldmodel->brush.num_leafs, r_refdef.worldmodel->num_surfaces, r_refdef.worldmodel->brush.shadowmesh ? r_refdef.worldmodel->brush.shadowmesh->numtriangles : r_refdef.worldmodel->surfmesh.num_triangles, r_refdef.worldmodel->surfmesh.num_triangles);
-		r_refdef.worldmodel->GetLightInfo(r_refdef.worldentity, rtlight->shadoworigin, rtlight->radius, rsurface.rtlight_cullmins, rsurface.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_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);
+		R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
 		leaflist = r_shadow_buffer_leaflist;
 		leafpvs = r_shadow_buffer_leafpvs;
 		surfacelist = r_shadow_buffer_surfacelist;
+		//surfacesides = r_shadow_buffer_surfacesides;
 		shadowtrispvs = r_shadow_buffer_shadowtrispvs;
 		lighttrispvs = r_shadow_buffer_lighttrispvs;
 		// if the reduced leaf bounds are offscreen, skip it
-		if (R_CullBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
+		if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
 			return;
 	}
 	else
@@ -2892,6 +3470,7 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
 		leafpvs = NULL;
 		numsurfaces = 0;
 		surfacelist = NULL;
+		//surfacesides = NULL;
 		shadowtrispvs = NULL;
 		lighttrispvs = NULL;
 	}
@@ -2899,236 +3478,930 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
 	if (numleafs)
 	{
 		for (i = 0;i < numleafs;i++)
-			if (r_viewcache.world_leafvisible[leaflist[i]])
+			if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
 				break;
 		if (i == numleafs)
 			return;
 	}
-	// set up a scissor rectangle for this light
-	if (R_Shadow_ScissorForBBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
-		return;
-
-	R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
 
 	// make a list of lit entities and shadow casting entities
 	numlightentities = 0;
 	numlightentities_noselfshadow = 0;
 	numshadowentities = 0;
 	numshadowentities_noselfshadow = 0;
+
 	// add dynamic entities that are lit by the light
-	if (r_drawentities.integer)
+	for (i = 0;i < r_refdef.scene.numentities;i++)
 	{
-		for (i = 0;i < r_refdef.numentities;i++)
+		dp_model_t *model;
+		entity_render_t *ent = r_refdef.scene.entities[i];
+		vec3_t org;
+		if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
+			continue;
+		// skip the object entirely if it is not within the valid
+		// shadow-casting region (which includes the lit region)
+		if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
+			continue;
+		if (!(model = ent->model))
+			continue;
+		if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
 		{
-			model_t *model;
-			entity_render_t *ent = r_refdef.entities[i];
-			vec3_t org;
-			if (!BoxesOverlap(ent->mins, ent->maxs, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
-				continue;
-			// skip the object entirely if it is not within the valid
-			// shadow-casting region (which includes the lit region)
-			if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rsurface.rtlight_numfrustumplanes, rsurface.rtlight_frustumplanes))
+			// this entity wants to receive light, is visible, and is
+			// inside the light box
+			// TODO: check if the surfaces in the model can receive light
+			// so now check if it's in a leaf seen by the light
+			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))
 				continue;
-			if (!(model = ent->model))
-				continue;
-			if (r_viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
+			if (ent->flags & RENDER_NOSELFSHADOW)
+				lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
+			else
+				lightentities[numlightentities++] = ent;
+			// since it is lit, it probably also casts a shadow...
+			// about the VectorDistance2 - light emitting entities should not cast their own shadow
+			Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+			if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
 			{
-				// this entity wants to receive light, is visible, and is
-				// inside the light box
-				// TODO: check if the surfaces in the model can receive light
-				// so now check if it's in a leaf seen by the light
-				if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs))
-					continue;
-				if (ent->flags & RENDER_NOSELFSHADOW)
-					lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
+				// note: exterior models without the RENDER_NOSELFSHADOW
+				// flag still create a RENDER_NOSELFSHADOW shadow but
+				// are lit normally, this means that they are
+				// self-shadowing but do not shadow other
+				// RENDER_NOSELFSHADOW entities such as the gun
+				// (very weird, but keeps the player shadow off the gun)
+				if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
+					shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
 				else
-					lightentities[numlightentities++] = ent;
-				// since it is lit, it probably also casts a shadow...
-				// about the VectorDistance2 - light emitting entities should not cast their own shadow
-				Matrix4x4_OriginFromMatrix(&ent->matrix, org);
-				if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
-				{
-					// note: exterior models without the RENDER_NOSELFSHADOW
-					// flag still create a RENDER_NOSELFSHADOW shadow but
-					// are lit normally, this means that they are
-					// self-shadowing but do not shadow other
-					// RENDER_NOSELFSHADOW entities such as the gun
-					// (very weird, but keeps the player shadow off the gun)
-					if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
-						shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
-					else
-						shadowentities[numshadowentities++] = ent;
-				}
+					shadowentities[numshadowentities++] = ent;
 			}
-			else if (ent->flags & RENDER_SHADOW)
+		}
+		else if (ent->flags & RENDER_SHADOW)
+		{
+			// this entity is not receiving light, but may still need to
+			// cast a shadow...
+			// TODO: check if the surfaces in the model can cast shadow
+			// now check if it is in a leaf seen by the light
+			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))
+				continue;
+			// about the VectorDistance2 - light emitting entities should not cast their own shadow
+			Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+			if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
 			{
-				// this entity is not receiving light, but may still need to
-				// cast a shadow...
-				// TODO: check if the surfaces in the model can cast shadow
-				// now check if it is in a leaf seen by the light
-				if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs))
-					continue;
-				// about the VectorDistance2 - light emitting entities should not cast their own shadow
-				Matrix4x4_OriginFromMatrix(&ent->matrix, org);
-				if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
-				{
-					if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
-						shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
-					else
-						shadowentities[numshadowentities++] = ent;
-				}
+				if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
+					shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
+				else
+					shadowentities[numshadowentities++] = ent;
 			}
 		}
 	}
 
 	// return if there's nothing at all to light
-	if (!numlightentities && !numsurfaces)
+	if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
+		return;
+
+	// count this light in the r_speeds
+	r_refdef.stats.lights++;
+
+	// flag it as worth drawing later
+	rtlight->draw = true;
+
+	// cache all the animated entities that cast a shadow but are not visible
+	for (i = 0;i < numshadowentities;i++)
+		if (!shadowentities[i]->animcache_vertex3f)
+			R_AnimCache_GetEntity(shadowentities[i], false, false);
+	for (i = 0;i < numshadowentities_noselfshadow;i++)
+		if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
+			R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
+
+	// allocate some temporary memory for rendering this light later in the frame
+	// reusable buffers need to be copied, static data can be used as-is
+	rtlight->cached_numlightentities               = numlightentities;
+	rtlight->cached_numlightentities_noselfshadow  = numlightentities_noselfshadow;
+	rtlight->cached_numshadowentities              = numshadowentities;
+	rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
+	rtlight->cached_numsurfaces                    = numsurfaces;
+	rtlight->cached_lightentities                  = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
+	rtlight->cached_lightentities_noselfshadow     = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
+	rtlight->cached_shadowentities                 = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
+	rtlight->cached_shadowentities_noselfshadow    = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
+	if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
+	{
+		int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
+		int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
+		rtlight->cached_shadowtrispvs                  =   (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
+		rtlight->cached_lighttrispvs                   =   (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
+		rtlight->cached_surfacelist                    =              (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
+	}
+	else
+	{
+		// compiled light data
+		rtlight->cached_shadowtrispvs = shadowtrispvs;
+		rtlight->cached_lighttrispvs = lighttrispvs;
+		rtlight->cached_surfacelist = surfacelist;
+	}
+}
+
+void R_Shadow_DrawLight(rtlight_t *rtlight)
+{
+	int i;
+	int numsurfaces;
+	unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
+	int numlightentities;
+	int numlightentities_noselfshadow;
+	int numshadowentities;
+	int numshadowentities_noselfshadow;
+	entity_render_t **lightentities;
+	entity_render_t **lightentities_noselfshadow;
+	entity_render_t **shadowentities;
+	entity_render_t **shadowentities_noselfshadow;
+	int *surfacelist;
+	static unsigned char entitysides[MAX_EDICTS];
+	static unsigned char entitysides_noselfshadow[MAX_EDICTS];
+	vec3_t nearestpoint;
+	vec_t distance;
+	qboolean castshadows;
+	int lodlinear;
+
+	// check if we cached this light this frame (meaning it is worth drawing)
+	if (!rtlight->draw)
+		return;
+
+	// if R_FrameData_Store ran out of space we skip anything dependent on it
+	if (r_framedata_failed)
+		return;
+
+	numlightentities = rtlight->cached_numlightentities;
+	numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
+	numshadowentities = rtlight->cached_numshadowentities;
+	numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
+	numsurfaces = rtlight->cached_numsurfaces;
+	lightentities = rtlight->cached_lightentities;
+	lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
+	shadowentities = rtlight->cached_shadowentities;
+	shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
+	shadowtrispvs = rtlight->cached_shadowtrispvs;
+	lighttrispvs = rtlight->cached_lighttrispvs;
+	surfacelist = rtlight->cached_surfacelist;
+
+	// set up a scissor rectangle for this light
+	if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
 		return;
 
 	// don't let sound skip if going slow
-	if (r_refdef.extraupdate)
+	if (r_refdef.scene.extraupdate)
 		S_ExtraUpdate ();
 
 	// make this the active rtlight for rendering purposes
 	R_Shadow_RenderMode_ActiveLight(rtlight);
-	// count this light in the r_speeds
-	r_refdef.stats.lights++;
 
-	if (r_showshadowvolumes.integer && r_view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.rtworldshadows : r_refdef.rtdlightshadows))
+	if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
 	{
 		// optionally draw visible shape of the shadow volumes
 		// for performance analysis by level designers
 		R_Shadow_RenderMode_VisibleShadowVolumes();
 		if (numsurfaces)
-			R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs);
+			R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
 		for (i = 0;i < numshadowentities;i++)
 			R_Shadow_DrawEntityShadow(shadowentities[i]);
 		for (i = 0;i < numshadowentities_noselfshadow;i++)
 			R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
+		R_Shadow_RenderMode_VisibleLighting(false, false);
 	}
 
-	if (gl_stencil && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.rtworldshadows : r_refdef.rtdlightshadows))
+	if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
 	{
-		// draw stencil shadow volumes to mask off pixels that are in shadow
-		// so that they won't receive lighting
-		R_Shadow_RenderMode_StencilShadowVolumes(true);
+		// optionally draw the illuminated areas
+		// for performance analysis by level designers
+		R_Shadow_RenderMode_VisibleLighting(false, false);
 		if (numsurfaces)
-			R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs);
-		for (i = 0;i < numshadowentities;i++)
-			R_Shadow_DrawEntityShadow(shadowentities[i]);
+			R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
+		for (i = 0;i < numlightentities;i++)
+			R_Shadow_DrawEntityLight(lightentities[i]);
+		for (i = 0;i < numlightentities_noselfshadow;i++)
+			R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
+	}
+
+	castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
+
+	nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
+	nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
+	nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
+	distance = VectorDistance(nearestpoint, r_refdef.view.origin);
+
+	lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
+	//lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
+	lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
+
+	if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
+	{
+		float borderbias;
+		int side;
+		int size;
+		int castermask = 0;
+		int receivermask = 0;
+		matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
+		Matrix4x4_Abs(&radiustolight);
+
+		r_shadow_shadowmaplod = 0;
+		for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
+			if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
+				r_shadow_shadowmaplod = i;
+
+		size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
+			
+		borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
+
+		surfacesides = NULL;
+		if (numsurfaces)
+		{
+			if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
+			{
+				castermask = rtlight->static_shadowmap_casters;
+				receivermask = rtlight->static_shadowmap_receivers;
+			}
+			else
+			{
+				surfacesides = r_shadow_buffer_surfacesides;
+				for(i = 0;i < numsurfaces;i++)
+				{
+					msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
+					surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);		
+					castermask |= surfacesides[i];
+					receivermask |= surfacesides[i];
+				}
+			}
+		}
+		if (receivermask < 0x3F) 
+		{
+			for (i = 0;i < numlightentities;i++)
+				receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
+			if (receivermask < 0x3F)
+				for(i = 0; i < numlightentities_noselfshadow;i++)
+					receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
+		}
+
+		receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
+
+		if (receivermask)
+		{
+			for (i = 0;i < numshadowentities;i++)
+				castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
+			for (i = 0;i < numshadowentities_noselfshadow;i++)
+				castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias)); 
+		}
+
+		//Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
+
+		// render shadow casters into 6 sided depth texture
+		for (side = 0;side < 6;side++) if (receivermask & (1 << side))
+		{
+			R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
+			if (! (castermask & (1 << side))) continue;
+			if (numsurfaces)
+				R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
+			for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
+				R_Shadow_DrawEntityShadow(shadowentities[i]);
+		}
+
 		if (numlightentities_noselfshadow)
 		{
+			// render lighting using the depth texture as shadowmap
 			// draw lighting in the unmasked areas
-			R_Shadow_RenderMode_Lighting(true, false);
+			R_Shadow_RenderMode_Lighting(false, false, true);
 			for (i = 0;i < numlightentities_noselfshadow;i++)
-				R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist);
+				R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
+		}
 
-			// optionally draw the illuminated areas
-			// for performance analysis by level designers
-			if (r_showlighting.integer && r_view.showdebug)
+		// render shadow casters into 6 sided depth texture
+		if (numshadowentities_noselfshadow)
+		{
+			for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
 			{
-				R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false);
-				for (i = 0;i < numlightentities_noselfshadow;i++)
-					R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist);
+				R_Shadow_RenderMode_ShadowMap(side, 0, size);
+				for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
+					R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
 			}
-
-			R_Shadow_RenderMode_StencilShadowVolumes(false);
 		}
+
+		// render lighting using the depth texture as shadowmap
+		// draw lighting in the unmasked areas
+		R_Shadow_RenderMode_Lighting(false, false, true);
+		// draw lighting in the unmasked areas
+		if (numsurfaces)
+			R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
+		for (i = 0;i < numlightentities;i++)
+			R_Shadow_DrawEntityLight(lightentities[i]);
+	}
+	else if (castshadows && vid.stencil)
+	{
+		// draw stencil shadow volumes to mask off pixels that are in shadow
+		// so that they won't receive lighting
+		GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
+		R_Shadow_ClearStencil();
+
+		if (numsurfaces)
+			R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
+		for (i = 0;i < numshadowentities;i++)
+			R_Shadow_DrawEntityShadow(shadowentities[i]);
+
+		// draw lighting in the unmasked areas
+		R_Shadow_RenderMode_Lighting(true, false, false);
+		for (i = 0;i < numlightentities_noselfshadow;i++)
+			R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
+
 		for (i = 0;i < numshadowentities_noselfshadow;i++)
 			R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
 
-		if (numsurfaces + numlightentities)
+		// draw lighting in the unmasked areas
+		R_Shadow_RenderMode_Lighting(true, false, false);
+		if (numsurfaces)
+			R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
+		for (i = 0;i < numlightentities;i++)
+			R_Shadow_DrawEntityLight(lightentities[i]);
+	}
+	else
+	{
+		// draw lighting in the unmasked areas
+		R_Shadow_RenderMode_Lighting(false, false, false);
+		if (numsurfaces)
+			R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
+		for (i = 0;i < numlightentities;i++)
+			R_Shadow_DrawEntityLight(lightentities[i]);
+		for (i = 0;i < numlightentities_noselfshadow;i++)
+			R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
+	}
+
+	if (r_shadow_usingdeferredprepass)
+	{
+		// when rendering deferred lighting, we simply rasterize the box
+		if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
+			R_Shadow_RenderMode_DrawDeferredLight(false, true);
+		else if (castshadows && vid.stencil)
+			R_Shadow_RenderMode_DrawDeferredLight(true, false);
+		else
+			R_Shadow_RenderMode_DrawDeferredLight(false, false);
+	}
+}
+
+static void R_Shadow_FreeDeferred(void)
+{
+	R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
+	r_shadow_prepassgeometryfbo = 0;
+
+	R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingfbo);
+	r_shadow_prepasslightingfbo = 0;
+
+	if (r_shadow_prepassgeometrydepthtexture)
+		R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
+	r_shadow_prepassgeometrydepthtexture = NULL;
+
+	if (r_shadow_prepassgeometrydepthcolortexture)
+		R_FreeTexture(r_shadow_prepassgeometrydepthcolortexture);
+	r_shadow_prepassgeometrydepthcolortexture = NULL;
+
+	if (r_shadow_prepassgeometrynormalmaptexture)
+		R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
+	r_shadow_prepassgeometrynormalmaptexture = NULL;
+
+	if (r_shadow_prepasslightingdiffusetexture)
+		R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
+	r_shadow_prepasslightingdiffusetexture = NULL;
+
+	if (r_shadow_prepasslightingspeculartexture)
+		R_FreeTexture(r_shadow_prepasslightingspeculartexture);
+	r_shadow_prepasslightingspeculartexture = NULL;
+}
+
+void R_Shadow_DrawPrepass(void)
+{
+	int i;
+	int flag;
+	int lnum;
+	size_t lightindex;
+	dlight_t *light;
+	size_t range;
+	entity_render_t *ent;
+	float clearcolor[4];
+
+	GL_AlphaTest(false);
+	R_Mesh_ResetTextureState();
+	GL_DepthMask(true);
+	GL_ColorMask(1,1,1,1);
+	GL_BlendFunc(GL_ONE, GL_ZERO);
+	GL_Color(1,1,1,1);
+	GL_DepthTest(true);
+	R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
+	Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
+	GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
+	if (r_timereport_active)
+		R_TimeReport("prepasscleargeom");
+
+	if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
+		r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
+	if (r_timereport_active)
+		R_TimeReport("prepassworld");
+
+	for (i = 0;i < r_refdef.scene.numentities;i++)
+	{
+		if (!r_refdef.viewcache.entityvisible[i])
+			continue;
+		ent = r_refdef.scene.entities[i];
+		if (ent->model && ent->model->DrawPrepass != NULL)
+			ent->model->DrawPrepass(ent);
+	}
+
+	if (r_timereport_active)
+		R_TimeReport("prepassmodels");
+
+	GL_DepthMask(false);
+	GL_ColorMask(1,1,1,1);
+	GL_Color(1,1,1,1);
+	GL_DepthTest(true);
+	R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+	Vector4Set(clearcolor, 0, 0, 0, 0);
+	GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
+	if (r_timereport_active)
+		R_TimeReport("prepassclearlit");
+
+	R_Shadow_RenderMode_Begin();
+
+	flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
+	if (r_shadow_debuglight.integer >= 0)
+	{
+		lightindex = r_shadow_debuglight.integer;
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		if (light && (light->flags & flag))
+			R_Shadow_DrawLight(&light->rtlight);
+	}
+	else
+	{
+		range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+		for (lightindex = 0;lightindex < range;lightindex++)
 		{
-			// draw lighting in the unmasked areas
-			R_Shadow_RenderMode_Lighting(true, false);
-			if (numsurfaces)
-				R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
-			for (i = 0;i < numlightentities;i++)
-				R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
+			light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+			if (light && (light->flags & flag))
+				R_Shadow_DrawLight(&light->rtlight);
+		}
+	}
+	if (r_refdef.scene.rtdlight)
+		for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
+			R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
+
+	R_Mesh_ResetRenderTargets();
+
+	R_Shadow_RenderMode_End();
+
+	if (r_timereport_active)
+		R_TimeReport("prepasslights");
+}
+
+void R_Shadow_DrawLightSprites(void);
+void R_Shadow_PrepareLights(void)
+{
+	int flag;
+	int lnum;
+	size_t lightindex;
+	dlight_t *light;
+	size_t range;
+	float f;
+	GLenum status;
+
+	if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
+		(r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
+		r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) || 
+		r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer || 
+		r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer || 
+		r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
+		R_Shadow_FreeShadowMaps();
+
+	r_shadow_usingshadowmaportho = false;
+
+	switch (vid.renderpath)
+	{
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+	case RENDERPATH_D3D9:
+	case RENDERPATH_D3D10:
+	case RENDERPATH_D3D11:
+		if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
+		{
+			r_shadow_usingdeferredprepass = false;
+			if (r_shadow_prepass_width)
+				R_Shadow_FreeDeferred();
+			r_shadow_prepass_width = r_shadow_prepass_height = 0;
+			break;
+		}
+
+		if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
+		{
+			R_Shadow_FreeDeferred();
+
+			r_shadow_usingdeferredprepass = true;
+			r_shadow_prepass_width = vid.width;
+			r_shadow_prepass_height = vid.height;
+			r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
+			switch (vid.renderpath)
+			{
+			case RENDERPATH_D3D9:
+				r_shadow_prepassgeometrydepthcolortexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrydepthcolormap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
+				break;
+			default:
+				break;
+			}
+			r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
+			r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
+			r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
+
+			// set up the geometry pass fbo (depth + normalmap)
+			r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
+			R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
+			// render depth into one texture and normalmap into the other
+			if (qglDrawBuffersARB)
+			{
+				qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
+				qglReadBuffer(GL_NONE);CHECKGLERROR
+				status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
+				if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
+				{
+					Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
+					Cvar_SetValueQuick(&r_shadow_deferred, 0);
+					r_shadow_usingdeferredprepass = false;
+				}
+			}
 
-			// optionally draw the illuminated areas
-			// for performance analysis by level designers
-			if (r_showlighting.integer && r_view.showdebug)
+			// set up the lighting pass fbo (diffuse + specular)
+			r_shadow_prepasslightingfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+			R_Mesh_SetRenderTargets(r_shadow_prepasslightingfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
+			// render diffuse into one texture and specular into another,
+			// with depth and normalmap bound as textures,
+			// with depth bound as attachment as well
+			if (qglDrawBuffersARB)
 			{
-				R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false);
-				if (numsurfaces)
-					R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
-				for (i = 0;i < numlightentities;i++)
-					R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
+				qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
+				qglReadBuffer(GL_NONE);CHECKGLERROR
+				status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
+				if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
+				{
+					Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
+					Cvar_SetValueQuick(&r_shadow_deferred, 0);
+					r_shadow_usingdeferredprepass = false;
+				}
 			}
 		}
+		break;
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL11:
+		r_shadow_usingdeferredprepass = false;
+		break;
+	}
+
+	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);
+
+	flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
+	if (r_shadow_debuglight.integer >= 0)
+	{
+		lightindex = r_shadow_debuglight.integer;
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		if (light && (light->flags & flag))
+			R_Shadow_PrepareLight(&light->rtlight);
 	}
 	else
 	{
-		if (numsurfaces + numlightentities)
+		range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+		for (lightindex = 0;lightindex < range;lightindex++)
+		{
+			light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+			if (light && (light->flags & flag))
+				R_Shadow_PrepareLight(&light->rtlight);
+		}
+	}
+	if (r_refdef.scene.rtdlight)
+	{
+		for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
+			R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
+	}
+	else if(gl_flashblend.integer)
+	{
+		for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
 		{
-			// draw lighting in the unmasked areas
-			R_Shadow_RenderMode_Lighting(false, false);
-			if (numsurfaces)
-				R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
-			for (i = 0;i < numlightentities;i++)
-				R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
-			for (i = 0;i < numlightentities_noselfshadow;i++)
-				R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist);
-
-			// optionally draw the illuminated areas
-			// for performance analysis by level designers
-			if (r_showlighting.integer && r_view.showdebug)
-			{
-				R_Shadow_RenderMode_VisibleLighting(false, false);
-				if (numsurfaces)
-					R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
-				for (i = 0;i < numlightentities;i++)
-					R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
-				for (i = 0;i < numlightentities_noselfshadow;i++)
-					R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist);
-			}
+			rtlight_t *rtlight = r_refdef.scene.lights[lnum];
+			f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
+			VectorScale(rtlight->color, f, rtlight->currentcolor);
 		}
 	}
+
+	if (r_editlights.integer)
+		R_Shadow_DrawLightSprites();
 }
 
-void R_Shadow_DrawLightSprites(void);
-void R_ShadowVolumeLighting(qboolean visible)
+void R_Shadow_DrawLights(void)
 {
 	int flag;
 	int lnum;
 	size_t lightindex;
 	dlight_t *light;
-
-	if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
-		R_Shadow_EditLights_Reload_f();
-
-	if (r_editlights.integer)
-		R_Shadow_DrawLightSprites();
+	size_t range;
 
 	R_Shadow_RenderMode_Begin();
 
-	flag = r_refdef.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
+	flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
 	if (r_shadow_debuglight.integer >= 0)
 	{
 		lightindex = r_shadow_debuglight.integer;
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (light && (light->flags & flag))
-			R_DrawRTLight(&light->rtlight, visible);
+			R_Shadow_DrawLight(&light->rtlight);
 	}
 	else
 	{
-		for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+		range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+		for (lightindex = 0;lightindex < range;lightindex++)
 		{
-			light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+			light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 			if (light && (light->flags & flag))
-				R_DrawRTLight(&light->rtlight, visible);
+				R_Shadow_DrawLight(&light->rtlight);
 		}
 	}
-	if (r_refdef.rtdlight)
-		for (lnum = 0;lnum < r_refdef.numlights;lnum++)
-			R_DrawRTLight(&r_refdef.lights[lnum], visible);
+	if (r_refdef.scene.rtdlight)
+		for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
+			R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
 
 	R_Shadow_RenderMode_End();
 }
 
-extern void R_SetupView(void);
+extern const float r_screenvertex3f[12];
+extern void R_SetupView(qboolean allowwaterclippingplane);
+extern void R_ResetViewRendering3D(void);
+extern void R_ResetViewRendering2D(void);
+extern cvar_t r_shadows;
+extern cvar_t r_shadows_darken;
+extern cvar_t r_shadows_drawafterrtlighting;
+extern cvar_t r_shadows_castfrombmodels;
 extern cvar_t r_shadows_throwdistance;
+extern cvar_t r_shadows_throwdirection;
+extern cvar_t r_shadows_focus;
+extern cvar_t r_shadows_shadowmapscale;
+
+void R_Shadow_PrepareModelShadows(void)
+{
+	int i;
+	float scale, size, radius, dot1, dot2;
+	vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
+	entity_render_t *ent;
+
+	if (!r_refdef.scene.numentities)
+		return;
+
+	switch (r_shadow_shadowmode)
+	{
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		if (r_shadows.integer >= 2) 
+			break;
+		// fall through
+	case R_SHADOW_SHADOWMODE_STENCIL:
+		for (i = 0;i < r_refdef.scene.numentities;i++)
+		{
+			ent = r_refdef.scene.entities[i];
+			if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
+				R_AnimCache_GetEntity(ent, false, false);
+		}
+		return;
+	default:
+		return;
+	}
+
+	size = 2*r_shadow_shadowmapmaxsize;
+	scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
+	radius = 0.5f * size / scale;
+
+	Math_atov(r_shadows_throwdirection.string, shadowdir);
+	VectorNormalize(shadowdir);
+	dot1 = DotProduct(r_refdef.view.forward, shadowdir);
+	dot2 = DotProduct(r_refdef.view.up, shadowdir);
+	if (fabs(dot1) <= fabs(dot2))
+		VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
+	else
+		VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
+	VectorNormalize(shadowforward);
+	CrossProduct(shadowdir, shadowforward, shadowright);
+	Math_atov(r_shadows_focus.string, shadowfocus);
+	VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
+	VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
+	VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
+	VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
+	if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
+		dot1 = 1;
+	VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
+
+	shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
+	shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
+	shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
+	shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
+	shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
+	shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
+
+	for (i = 0;i < r_refdef.scene.numentities;i++)
+	{
+		ent = r_refdef.scene.entities[i];
+		if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
+			continue;
+		// cast shadows from anything of the map (submodels are optional)
+		if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
+			R_AnimCache_GetEntity(ent, false, false);
+	}
+}
+
+void R_DrawModelShadowMaps(void)
+{
+	int i;
+	float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
+	entity_render_t *ent;
+	vec3_t relativelightorigin;
+	vec3_t relativelightdirection, relativeforward, relativeright;
+	vec3_t relativeshadowmins, relativeshadowmaxs;
+	vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
+	float m[12];
+	matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
+	r_viewport_t viewport;
+	GLuint fbo = 0;
+	float clearcolor[4];
+
+	if (!r_refdef.scene.numentities)
+		return;
+
+	switch (r_shadow_shadowmode)
+	{
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		break;
+	default:
+		return;
+	}
+
+	R_ResetViewRendering3D();
+	R_Shadow_RenderMode_Begin();
+	R_Shadow_RenderMode_ActiveLight(NULL);
+
+	switch (r_shadow_shadowmode)
+	{
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		if (!r_shadow_shadowmap2dtexture)
+			R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
+		fbo = r_shadow_fbo2d;
+		r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
+		r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
+		r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
+		break;
+	default:
+		break;
+	}
+
+	size = 2*r_shadow_shadowmapmaxsize;
+	scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
+	radius = 0.5f / scale;
+	nearclip = -r_shadows_throwdistance.value;
+	farclip = r_shadows_throwdistance.value;
+	bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
+
+	r_shadow_shadowmap_parameters[0] = size;
+	r_shadow_shadowmap_parameters[1] = size;
+	r_shadow_shadowmap_parameters[2] = 1.0;
+	r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
+
+	Math_atov(r_shadows_throwdirection.string, shadowdir);
+	VectorNormalize(shadowdir);
+	Math_atov(r_shadows_focus.string, shadowfocus);
+	VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
+	VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
+	VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
+	VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
+	dot1 = DotProduct(r_refdef.view.forward, shadowdir);
+	dot2 = DotProduct(r_refdef.view.up, shadowdir);
+	if (fabs(dot1) <= fabs(dot2)) 
+		VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
+	else
+		VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
+	VectorNormalize(shadowforward);
+	VectorM(scale, shadowforward, &m[0]);
+	if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
+		dot1 = 1;
+	m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
+	CrossProduct(shadowdir, shadowforward, shadowright);
+	VectorM(scale, shadowright, &m[4]);
+	m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
+	VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
+	m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
+	Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
+	Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
+	R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL); 
+
+	VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
+
+	R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
+	R_SetupShader_DepthOrShadow();
+	GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
+	GL_DepthMask(true);
+	GL_DepthTest(true);
+	R_SetViewport(&viewport);
+	GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
+	Vector4Set(clearcolor, 1,1,1,1);
+	// in D3D9 we have to render to a color texture shadowmap
+	// in GL we render directly to a depth texture only
+	if (r_shadow_shadowmap2dtexture)
+		GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
+	else
+		GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
+	// render into a slightly restricted region so that the borders of the
+	// shadowmap area fade away, rather than streaking across everything
+	// outside the usable area
+	GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
+
+#if 0
+	// debugging
+	R_Mesh_ResetRenderTargets();
+	R_SetupShader_ShowDepth();
+	GL_ColorMask(1,1,1,1);
+	GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
+#endif
+
+	for (i = 0;i < r_refdef.scene.numentities;i++)
+	{
+		ent = r_refdef.scene.entities[i];
+
+		// cast shadows from anything of the map (submodels are optional)
+		if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
+		{
+			relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
+			Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
+			Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
+			Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
+			Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
+			relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
+			relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
+			relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
+			relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
+			relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
+			relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
+			RSurf_ActiveModelEntity(ent, false, false, false);
+			ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
+			rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
+		}
+	}
+
+#if 0
+	if (r_test.integer)
+	{
+		unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
+		CHECKGLERROR
+		qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
+		CHECKGLERROR
+		Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
+		Cvar_SetValueQuick(&r_test, 0);
+		Z_Free(rawpixels);
+	}
+#endif
+
+	R_Shadow_RenderMode_End();
+
+	Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
+	Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
+	Matrix4x4_CreateScale3(&scalematrix, size, -size, 1); 
+	Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
+	Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
+	Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
+
+	switch (vid.renderpath)
+	{
+	case RENDERPATH_GL11:
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+		break;
+	case RENDERPATH_D3D9:
+	case RENDERPATH_D3D10:
+	case RENDERPATH_D3D11:
+#ifdef OPENGL_ORIENTATION
+		r_shadow_shadowmapmatrix.m[0][0]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[0][1]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[0][2]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[0][3]	*= -1.0f;
+#else
+		r_shadow_shadowmapmatrix.m[0][0]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[1][0]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[2][0]	*= -1.0f;
+		r_shadow_shadowmapmatrix.m[3][0]	*= -1.0f;
+#endif
+		break;
+	}
+
+	r_shadow_usingshadowmaportho = true;
+	switch (r_shadow_shadowmode)
+	{
+	case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
+		r_shadow_usingshadowmap2d = true;
+		break;
+	default:
+		break;
+	}
+}
+
 void R_DrawModelShadows(void)
 {
 	int i;
@@ -3137,264 +4410,394 @@ void R_DrawModelShadows(void)
 	vec3_t relativelightorigin;
 	vec3_t relativelightdirection;
 	vec3_t relativeshadowmins, relativeshadowmaxs;
-	float vertex3f[12];
+	vec3_t tmp, shadowdir;
 
-	if (!r_drawentities.integer || !gl_stencil)
+	if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
 		return;
 
-	CHECKGLERROR
-	GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
-
-	r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
+	R_ResetViewRendering3D();
+	//GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
+	//GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
+	R_Shadow_RenderMode_Begin();
+	R_Shadow_RenderMode_ActiveLight(NULL);
+	r_shadow_lightscissor[0] = r_refdef.view.x;
+	r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
+	r_shadow_lightscissor[2] = r_refdef.view.width;
+	r_shadow_lightscissor[3] = r_refdef.view.height;
+	R_Shadow_RenderMode_StencilShadowVolumes(false);
 
-	if (gl_ext_separatestencil.integer)
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_SEPARATESTENCIL;
-	else if (gl_ext_stenciltwoside.integer)
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCILTWOSIDE;
-	else
-		r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCIL;
+	// get shadow dir
+	if (r_shadows.integer == 2)
+	{
+		Math_atov(r_shadows_throwdirection.string, shadowdir);
+		VectorNormalize(shadowdir);
+	}
 
-	R_Shadow_RenderMode_StencilShadowVolumes(true);
+	R_Shadow_ClearStencil();
 
-	for (i = 0;i < r_refdef.numentities;i++)
+	for (i = 0;i < r_refdef.scene.numentities;i++)
 	{
-		ent = r_refdef.entities[i];
-		// cast shadows from anything that is not a submodel of the map
-		if (ent->model && ent->model->DrawShadowVolume != NULL && !ent->model->brush.submodel && (ent->flags & RENDER_SHADOW))
+		ent = r_refdef.scene.entities[i];
+
+		// cast shadows from anything of the map (submodels are optional)
+		if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
 		{
 			relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
 			VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
 			VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
-			VectorNegate(ent->modellight_lightdir, relativelightdirection);
+			if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
+				Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
+			else
+			{
+				if(ent->entitynumber != 0)
+				{
+					if(ent->entitynumber >= MAX_EDICTS) // csqc entity
+					{
+						// FIXME handle this
+						VectorNegate(ent->modellight_lightdir, relativelightdirection);
+					}
+					else
+					{
+						// networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
+						int entnum, entnum2, recursion;
+						entnum = entnum2 = ent->entitynumber;
+						for(recursion = 32; recursion > 0; --recursion)
+						{
+							entnum2 = cl.entities[entnum].state_current.tagentity;
+							if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
+								entnum = entnum2;
+							else
+								break;
+						}
+						if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
+						{
+							VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
+							// transform into modelspace of OUR entity
+							Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
+							Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
+						}
+						else
+							VectorNegate(ent->modellight_lightdir, relativelightdirection);
+					}
+				}
+				else
+					VectorNegate(ent->modellight_lightdir, relativelightdirection);
+			}
+
 			VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
-			RSurf_ActiveModelEntity(ent, false, false);
-			ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->surfacelist, relativeshadowmins, relativeshadowmaxs);
+			RSurf_ActiveModelEntity(ent, false, false, false);
+			ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
+			rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
 		}
 	}
 
 	// not really the right mode, but this will disable any silly stencil features
-	R_Shadow_RenderMode_VisibleLighting(true, true);
-
-	// vertex coordinates for a quad that covers the screen exactly
-	vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
-	vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
-	vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
-	vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
+	R_Shadow_RenderMode_End();
 
 	// set up ortho view for rendering this pass
-	GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
-	GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
-	GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
-	GL_ScissorTest(true);
-	R_Mesh_Matrix(&identitymatrix);
-	R_Mesh_ResetTextureState();
-	R_Mesh_VertexPointer(vertex3f, 0, 0);
-	R_Mesh_ColorPointer(NULL, 0, 0);
-
-	// set up a 50% darkening blend on shadowed areas
+	//GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
+	//GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
+	//GL_ScissorTest(true);
+	//R_EntityMatrix(&identitymatrix);
+	//R_Mesh_ResetTextureState();
+	R_ResetViewRendering2D();
+
+	// set up a darkening blend on shadowed areas
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	GL_DepthRange(0, 1);
-	GL_DepthTest(false);
-	GL_DepthMask(false);
-	GL_PolygonOffset(0, 0);CHECKGLERROR
-	GL_Color(0, 0, 0, 0.5);
-	GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
-	qglDepthFunc(GL_ALWAYS);CHECKGLERROR
-	qglEnable(GL_STENCIL_TEST);CHECKGLERROR
-	qglStencilMask(~0);CHECKGLERROR
-	qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
-	qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR
+	//GL_DepthRange(0, 1);
+	//GL_DepthTest(false);
+	//GL_DepthMask(false);
+	//GL_PolygonOffset(0, 0);CHECKGLERROR
+	GL_Color(0, 0, 0, r_shadows_darken.value);
+	//GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
+	//GL_DepthFunc(GL_ALWAYS);
+	R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
 
 	// apply the blend to the shadowed areas
-	R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+	R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
+	R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
+	R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
 
-	// restoring the perspective view is done by R_RenderScene
-	//R_SetupView();
+	// restore the viewport
+	R_SetViewport(&r_refdef.view.viewport);
 
 	// restore other state to normal
-	R_Shadow_RenderMode_End();
+	//R_Shadow_RenderMode_End();
+}
+
+void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
+{
+	float zdist;
+	vec3_t centerorigin;
+	float vertex3f[12];
+	// if it's too close, skip it
+	if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
+		return;
+	zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
+	if (zdist < 32)
+ 		return;
+	if (usequery && r_numqueries + 2 <= r_maxqueries)
+	{
+		rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
+		rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
+		// 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
+		VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
+
+		switch(vid.renderpath)
+		{
+		case RENDERPATH_GL20:
+		case RENDERPATH_GL13:
+		case RENDERPATH_GL11:
+		case RENDERPATH_CGGL:
+			CHECKGLERROR
+			// NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
+			qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
+			GL_DepthFunc(GL_ALWAYS);
+			R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
+			R_Mesh_PrepareVertices_Position_Arrays(4, vertex3f);
+			R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
+			qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
+			GL_DepthFunc(GL_LEQUAL);
+			qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
+			R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
+			R_Mesh_PrepareVertices_Position_Arrays(4, vertex3f);
+			R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
+			qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
+			CHECKGLERROR
+			break;
+		case RENDERPATH_D3D9:
+			Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		case RENDERPATH_D3D10:
+			Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		case RENDERPATH_D3D11:
+			Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		}
+	}
+	rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
+}
+
+static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
+
+void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
+{
+	vec3_t color;
+	GLint allpixels = 0, visiblepixels = 0;
+	// now we have to check the query result
+	if (rtlight->corona_queryindex_visiblepixels)
+	{
+		switch(vid.renderpath)
+		{
+		case RENDERPATH_GL20:
+		case RENDERPATH_GL13:
+		case RENDERPATH_GL11:
+		case RENDERPATH_CGGL:
+			CHECKGLERROR
+			qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
+			qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
+			CHECKGLERROR
+			break;
+		case RENDERPATH_D3D9:
+			Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		case RENDERPATH_D3D10:
+			Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		case RENDERPATH_D3D11:
+			Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+			break;
+		}
+		//Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
+		if (visiblepixels < 1 || allpixels < 1)
+			return;
+		rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
+		cscale *= rtlight->corona_visibility;
+	}
+	else
+	{
+		// FIXME: these traces should scan all render entities instead of cl.world
+		if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
+			return;
+	}
+	VectorScale(rtlight->currentcolor, cscale, color);
+	if (VectorLength(color) > (1.0f / 256.0f))
+	{
+		float vertex3f[12];
+		qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
+		if(negated)
+		{
+			VectorNegate(color, color);
+			switch(vid.renderpath)
+			{
+			case RENDERPATH_GL11:
+			case RENDERPATH_GL13:
+			case RENDERPATH_GL20:
+			case RENDERPATH_CGGL:
+				qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
+				break;
+			case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+				IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
+#endif
+				break;
+			case RENDERPATH_D3D10:
+				Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+				break;
+			case RENDERPATH_D3D11:
+				Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+				break;
+			}
+		}
+		R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
+		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);
+		R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
+		if(negated)
+		{
+			switch(vid.renderpath)
+			{
+			case RENDERPATH_GL11:
+			case RENDERPATH_GL13:
+			case RENDERPATH_GL20:
+			case RENDERPATH_CGGL:
+				qglBlendEquationEXT(GL_FUNC_ADD_EXT);
+				break;
+			case RENDERPATH_D3D9:
+#ifdef SUPPORTD3D
+				IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
+#endif
+				break;
+			case RENDERPATH_D3D10:
+				Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+				break;
+			case RENDERPATH_D3D11:
+				Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+				break;
+			}
+		}
+	}
 }
 
-void R_DrawCoronas(void)
+void R_Shadow_DrawCoronas(void)
 {
 	int i, flag;
-	float cscale, scale;
+	qboolean usequery = false;
 	size_t lightindex;
 	dlight_t *light;
 	rtlight_t *rtlight;
+	size_t range;
 	if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
 		return;
-	R_Mesh_Matrix(&identitymatrix);
-	flag = r_refdef.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
-	// FIXME: these traces should scan all render entities instead of cl.world
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
-	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+	if (r_waterstate.renderingscene)
+		return;
+	flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
+	R_EntityMatrix(&identitymatrix);
+
+	range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+
+	// check occlusion of coronas
+	// use GL_ARB_occlusion_query if available
+	// otherwise use raytraces
+	r_numqueries = 0;
+	switch (vid.renderpath)
+	{
+	case RENDERPATH_GL11:
+	case RENDERPATH_GL13:
+	case RENDERPATH_GL20:
+	case RENDERPATH_CGGL:
+		usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
+		if (usequery)
+		{
+			GL_ColorMask(0,0,0,0);
+			if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
+			if (r_maxqueries < MAX_OCCLUSION_QUERIES)
+			{
+				i = r_maxqueries;
+				r_maxqueries = (range + r_refdef.scene.numlights) * 4;
+				r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
+				CHECKGLERROR
+				qglGenQueriesARB(r_maxqueries - i, r_queries + i);
+				CHECKGLERROR
+			}
+			RSurf_ActiveWorldEntity();
+			GL_BlendFunc(GL_ONE, GL_ZERO);
+			GL_CullFace(GL_NONE);
+			GL_DepthMask(false);
+			GL_DepthRange(0, 1);
+			GL_PolygonOffset(0, 0);
+			GL_DepthTest(true);
+			R_Mesh_ResetTextureState();
+			R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
+		}
+		break;
+	case RENDERPATH_D3D9:
+		usequery = false;
+		//Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+		break;
+	case RENDERPATH_D3D10:
+		Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+		break;
+	case RENDERPATH_D3D11:
+		Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
+		break;
+	}
+	for (lightindex = 0;lightindex < range;lightindex++)
+	{
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
 		rtlight = &light->rtlight;
+		rtlight->corona_visibility = 0;
+		rtlight->corona_queryindex_visiblepixels = 0;
+		rtlight->corona_queryindex_allpixels = 0;
 		if (!(rtlight->flags & flag))
 			continue;
-		if (rtlight->corona * r_coronas.value <= 0)
+		if (rtlight->corona <= 0)
 			continue;
 		if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
 			continue;
-		cscale = rtlight->corona * r_coronas.value* 0.25f;
-		scale = rtlight->radius * rtlight->coronasizescale;
-		if (VectorDistance2(rtlight->shadoworigin, r_view.origin) < 16.0f * 16.0f)
-			continue;
-		if (CL_Move(r_view.origin, vec3_origin, vec3_origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
-			continue;
-		R_DrawSprite(GL_ONE, GL_ONE, r_shadow_lightcorona, NULL, true, false, rtlight->shadoworigin, r_view.right, r_view.up, scale, -scale, -scale, scale, rtlight->color[0] * cscale, rtlight->color[1] * cscale, rtlight->color[2] * cscale, 1);
+		R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
 	}
-	for (i = 0;i < r_refdef.numlights;i++)
+	for (i = 0;i < r_refdef.scene.numlights;i++)
 	{
-		rtlight = &r_refdef.lights[i];
+		rtlight = r_refdef.scene.lights[i];
+		rtlight->corona_visibility = 0;
+		rtlight->corona_queryindex_visiblepixels = 0;
+		rtlight->corona_queryindex_allpixels = 0;
 		if (!(rtlight->flags & flag))
 			continue;
 		if (rtlight->corona <= 0)
 			continue;
-		if (VectorDistance2(rtlight->shadoworigin, r_view.origin) < 32.0f * 32.0f)
-			continue;
-		if (gl_flashblend.integer)
-		{
-			cscale = rtlight->corona * 1.0f;
-			scale = rtlight->radius * rtlight->coronasizescale * 2.0f;
-		}
-		else
-		{
-			cscale = rtlight->corona * r_coronas.value* 0.25f;
-			scale = rtlight->radius * rtlight->coronasizescale;
-		}
-		if (VectorLength(rtlight->color) * cscale < (1.0f / 256.0f))
-			continue;
-		if (CL_Move(r_view.origin, vec3_origin, vec3_origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
-			continue;
-		R_DrawSprite(GL_ONE, GL_ONE, r_shadow_lightcorona, NULL, true, false, rtlight->shadoworigin, r_view.right, r_view.up, scale, -scale, -scale, scale, rtlight->color[0] * cscale, rtlight->color[1] * cscale, rtlight->color[2] * cscale, 1);
-	}
-}
-
-
-
-//static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
-typedef struct suffixinfo_s
-{
-	char *suffix;
-	qboolean flipx, flipy, flipdiagonal;
-}
-suffixinfo_t;
-static suffixinfo_t suffix[3][6] =
-{
-	{
-		{"px",   false, false, false},
-		{"nx",   false, false, false},
-		{"py",   false, false, false},
-		{"ny",   false, false, false},
-		{"pz",   false, false, false},
-		{"nz",   false, false, false}
-	},
-	{
-		{"posx", false, false, false},
-		{"negx", false, false, false},
-		{"posy", false, false, false},
-		{"negy", false, false, false},
-		{"posz", false, false, false},
-		{"negz", false, false, false}
-	},
-	{
-		{"rt",    true, false,  true},
-		{"lf",   false,  true,  true},
-		{"ft",    true,  true, false},
-		{"bk",   false, false, false},
-		{"up",    true, false,  true},
-		{"dn",    true, false,  true}
+		R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
 	}
-};
-
-static int componentorder[4] = {0, 1, 2, 3};
+	if (usequery)
+		GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
 
-rtexture_t *R_Shadow_LoadCubemap(const char *basename)
-{
-	int i, j, cubemapsize;
-	unsigned char *cubemappixels, *image_buffer;
-	rtexture_t *cubemaptexture;
-	char name[256];
-	// must start 0 so the first loadimagepixels has no requested width/height
-	cubemapsize = 0;
-	cubemappixels = NULL;
-	cubemaptexture = NULL;
-	// keep trying different suffix groups (posx, px, rt) until one loads
-	for (j = 0;j < 3 && !cubemappixels;j++)
-	{
-		// load the 6 images in the suffix group
-		for (i = 0;i < 6;i++)
-		{
-			// generate an image name based on the base and and suffix
-			dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
-			// load it
-			if ((image_buffer = loadimagepixelsbgra(name, false, false)))
-			{
-				// an image loaded, make sure width and height are equal
-				if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
-				{
-					// if this is the first image to load successfully, allocate the cubemap memory
-					if (!cubemappixels && image_width >= 1)
-					{
-						cubemapsize = image_width;
-						// note this clears to black, so unavailable sides are black
-						cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
-					}
-					// copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
-					if (cubemappixels)
-						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);
-				}
-				else
-					Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
-				// free the image
-				Mem_Free(image_buffer);
-			}
-		}
-	}
-	// if a cubemap loaded, upload it
-	if (cubemappixels)
+	// now draw the coronas using the query data for intensity info
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		if (!r_shadow_filters_texturepool)
-			r_shadow_filters_texturepool = R_AllocTexturePool();
-		cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, TEXF_PRECACHE | (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0), NULL);
-		Mem_Free(cubemappixels);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		if (!light)
+			continue;
+		rtlight = &light->rtlight;
+		if (rtlight->corona_visibility <= 0)
+			continue;
+		R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
 	}
-	else
+	for (i = 0;i < r_refdef.scene.numlights;i++)
 	{
-		Con_Printf("Failed to load Cubemap \"%s\", tried ", basename);
-		for (j = 0;j < 3;j++)
-			for (i = 0;i < 6;i++)
-				Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
-		Con_Print(" and was unable to find any of them.\n");
+		rtlight = r_refdef.scene.lights[i];
+		if (rtlight->corona_visibility <= 0)
+			continue;
+		if (gl_flashblend.integer)
+			R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
+		else
+			R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
 	}
-	return cubemaptexture;
 }
 
-rtexture_t *R_Shadow_Cubemap(const char *basename)
-{
-	int i;
-	for (i = 0;i < numcubemaps;i++)
-		if (!strcasecmp(cubemaps[i].basename, basename))
-			return cubemaps[i].texture;
-	if (i >= MAX_CUBEMAPS)
-		return r_texture_whitecube;
-	numcubemaps++;
-	strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename));
-	cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
-	if (!cubemaps[i].texture)
-		cubemaps[i].texture = r_texture_whitecube;
-	return cubemaps[i].texture;
-}
 
-void R_Shadow_FreeCubemaps(void)
-{
-	numcubemaps = 0;
-	R_FreeTexturePool(&r_shadow_filters_texturepool);
-}
 
 dlight_t *R_Shadow_NewWorldLight(void)
 {
@@ -3418,9 +4821,14 @@ void R_Shadow_UpdateWorldLight(dlight_t *light, vec3_t origin, vec3_t angles, ve
 	light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
 	light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
 	light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
+	/*
 	light->color[0] = max(color[0], 0);
 	light->color[1] = max(color[1], 0);
 	light->color[2] = max(color[2], 0);
+	*/
+	light->color[0] = color[0];
+	light->color[1] = color[1];
+	light->color[2] = color[2];
 	light->radius = max(radius, 0);
 	light->style = style;
 	light->shadow = shadowenable;
@@ -3449,14 +4857,14 @@ void R_Shadow_ClearWorldLights(void)
 {
 	size_t lightindex;
 	dlight_t *light;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (light)
 			R_Shadow_FreeWorldLight(light);
 	}
 	r_shadow_selectedlight = NULL;
-	R_Shadow_FreeCubemaps();
 }
 
 void R_Shadow_SelectLight(dlight_t *light)
@@ -3471,7 +4879,10 @@ void R_Shadow_SelectLight(dlight_t *light)
 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
 {
 	// this is never batched (there can be only one)
-	R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, r_editlights_sprcursor->tex, r_editlights_sprcursor->tex, false, false, r_editlights_cursorlocation, r_view.right, r_view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE, 1, 1, 1, 1);
+	float vertex3f[12];
+	R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
+	RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
+	R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
 }
 
 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
@@ -3479,12 +4890,16 @@ void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, co
 	float intensity;
 	float s;
 	vec3_t spritecolor;
-	cachepic_t *pic;
+	skinframe_t *skinframe;
+	float vertex3f[12];
 
 	// this is never batched (due to the ent parameter changing every time)
 	// so numsurfaces == 1 and surfacelist[0] == lightnumber
 	const dlight_t *light = (dlight_t *)ent;
 	s = EDLIGHTSPRSIZE;
+
+	R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
+
 	intensity = 0.5f;
 	VectorScale(light->color, intensity, spritecolor);
 	if (VectorLength(spritecolor) < 0.1732f)
@@ -3494,31 +4909,59 @@ void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, co
 
 	// draw light sprite
 	if (light->cubemapname[0] && !light->shadow)
-		pic = r_editlights_sprcubemapnoshadowlight;
+		skinframe = r_editlights_sprcubemapnoshadowlight;
 	else if (light->cubemapname[0])
-		pic = r_editlights_sprcubemaplight;
+		skinframe = r_editlights_sprcubemaplight;
 	else if (!light->shadow)
-		pic = r_editlights_sprnoshadowlight;
+		skinframe = r_editlights_sprnoshadowlight;
 	else
-		pic = r_editlights_sprlight;
-	R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, pic->tex, pic->tex, false, false, light->origin, r_view.right, r_view.up, s, -s, -s, s, spritecolor[0], spritecolor[1], spritecolor[2], 1);
+		skinframe = r_editlights_sprlight;
+
+	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);
+	R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
+
 	// draw selection sprite if light is selected
 	if (light->selected)
-		R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, r_editlights_sprselection->tex, r_editlights_sprselection->tex, false, false, light->origin, r_view.right, r_view.up, s, -s, -s, s, 1, 1, 1, 1);
-	// VorteX todo: add normalmode/realtime mode light overlay sprites?
+	{
+		RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
+		R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
+		// VorteX todo: add normalmode/realtime mode light overlay sprites?
+	}
 }
 
 void R_Shadow_DrawLightSprites(void)
 {
 	size_t lightindex;
 	dlight_t *light;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (light)
 			R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
 	}
-	R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
+	if (!r_editlights_lockcursor)
+		R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
+}
+
+int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
+{
+	unsigned int range;
+	dlight_t *light;
+	rtlight_t *rtlight;
+	range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
+	if (lightindex >= range)
+		return -1;
+	light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+	if (!light)
+		return 0;
+	rtlight = &light->rtlight;
+	//if (!(rtlight->flags & flag))
+	//	return 0;
+	VectorCopy(rtlight->shadoworigin, origin);
+	*radius = rtlight->radius;
+	VectorCopy(rtlight->color, color);
+	return 1;
 }
 
 void R_Shadow_SelectLightInView(void)
@@ -3527,19 +4970,23 @@ void R_Shadow_SelectLightInView(void)
 	dlight_t *best;
 	size_t lightindex;
 	dlight_t *light;
+	size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
 	best = NULL;
 	bestrating = 0;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+
+	if (r_editlights_lockcursor)
+		return;
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
-		VectorSubtract(light->origin, r_view.origin, temp);
-		rating = (DotProduct(temp, r_view.forward) / sqrt(DotProduct(temp, temp)));
+		VectorSubtract(light->origin, r_refdef.view.origin, temp);
+		rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
 		if (rating >= 0.95)
 		{
 			rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
-			if (bestrating < rating && CL_Move(light->origin, vec3_origin, vec3_origin, r_view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
+			if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
 			{
 				bestrating = rating;
 				best = light;
@@ -3554,13 +5001,12 @@ void R_Shadow_LoadWorldLights(void)
 	int n, a, style, shadow, flags;
 	char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
 	float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
-	if (r_refdef.worldmodel == NULL)
+	if (cl.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
-	strlcat (name, ".rtlights", sizeof (name));
+	dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
 	lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
 	if (lightsstring)
 	{
@@ -3598,7 +5044,18 @@ void R_Shadow_LoadWorldLights(void)
 				t++;
 			}
 			*s = 0;
-			a = sscanf(t, "%f %f %f %f %f %f %f %d %s %f %f %f %f %f %f %f %f %i", &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);
+#if _MSC_VER >= 1400
+#define sscanf sscanf_s
+#endif
+			cubemapname[sizeof(cubemapname)-1] = 0;
+#if MAX_QPATH != 128
+#error update this code if MAX_QPATH changes
+#endif
+			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
+#if _MSC_VER >= 1400
+, sizeof(cubemapname)
+#endif
+, &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
 			*s = tempchar;
 			if (a < 18)
 				flags = LIGHTFLAG_REALTIMEMODE;
@@ -3650,28 +5107,29 @@ void R_Shadow_SaveWorldLights(void)
 	char *buf, *oldbuf;
 	char name[MAX_QPATH];
 	char line[MAX_INPUTLINE];
-	if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
+	size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
+	// I hate lines which are 3 times my screen size :( --blub
+	if (!range)
 		return;
-	if (r_refdef.worldmodel == NULL)
+	if (cl.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
-	strlcat (name, ".rtlights", sizeof (name));
+	dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
 	bufchars = bufmaxchars = 0;
 	buf = NULL;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
 		if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
-			sprintf(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);
+			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);
 		else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
-			sprintf(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]);
+			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]);
 		else
-			sprintf(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);
+			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);
 		if (bufchars + strlen(line) > bufmaxchars)
 		{
 			bufmaxchars = bufchars + strlen(line) + 2048;
@@ -3701,13 +5159,12 @@ void R_Shadow_LoadLightsFile(void)
 	int n, a, style;
 	char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
 	float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
-	if (r_refdef.worldmodel == NULL)
+	if (cl.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
-	strlcat (name, ".lights", sizeof (name));
+	dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
 	lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
 	if (lightsstring)
 	{
@@ -3750,24 +5207,30 @@ typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX,
 
 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
 {
-	int entnum, style, islight, skin, pflags, effects, type, n;
+	int entnum;
+	int style;
+	int islight;
+	int skin;
+	int pflags;
+	//int effects;
+	int type;
+	int n;
 	char *entfiledata;
 	const char *data;
 	float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
 	char key[256], value[MAX_INPUTLINE];
 
-	if (r_refdef.worldmodel == NULL)
+	if (cl.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
 	// try to load a .ent file first
-	FS_StripExtension (r_refdef.worldmodel->name, key, sizeof (key));
-	strlcat (key, ".ent", sizeof (key));
+	dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
 	data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
 	// and if that is not found, fall back to the bsp file entity string
 	if (!data)
-		data = r_refdef.worldmodel->brush.entities;
+		data = cl.worldmodel->brush.entities;
 	if (!data)
 		return;
 	for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
@@ -3784,7 +5247,7 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
 		style = 0;
 		skin = 0;
 		pflags = 0;
-		effects = 0;
+		//effects = 0;
 		islight = false;
 		while (1)
 		{
@@ -3911,9 +5374,9 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
 				skin = (int)atof(value);
 			else if (!strcmp("pflags", key))
 				pflags = (int)atof(value);
-			else if (!strcmp("effects", key))
-				effects = (int)atof(value);
-			else if (r_refdef.worldmodel->type == mod_brushq3)
+			//else if (!strcmp("effects", key))
+			//	effects = (int)atof(value);
+			else if (cl.worldmodel->type == mod_brushq3)
 			{
 				if (!strcmp("scale", key))
 					lightscale = atof(value);
@@ -3971,8 +5434,8 @@ void R_Shadow_SetCursorLocationForView(void)
 	vec_t dist, push;
 	vec3_t dest, endpos;
 	trace_t trace;
-	VectorMA(r_view.origin, r_editlights_cursordistance.value, r_view.forward, dest);
-	trace = CL_Move(r_view.origin, vec3_origin, vec3_origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
+	VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
+	trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
 	if (trace.fraction < 1)
 	{
 		dist = trace.fraction * r_editlights_cursordistance.value;
@@ -3980,7 +5443,7 @@ void R_Shadow_SetCursorLocationForView(void)
 		if (push > dist)
 			push = dist;
 		push = -push;
-		VectorMA(trace.endpos, push, r_view.forward, endpos);
+		VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
 		VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
 	}
 	else
@@ -4010,9 +5473,9 @@ void R_Shadow_EditLights_Clear_f(void)
 
 void R_Shadow_EditLights_Reload_f(void)
 {
-	if (!r_refdef.worldmodel)
+	if (!cl.worldmodel)
 		return;
-	strlcpy(r_shadow_mapname, r_refdef.worldmodel->name, sizeof(r_shadow_mapname));
+	strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
 	R_Shadow_ClearWorldLights();
 	R_Shadow_LoadWorldLights();
 	if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
@@ -4025,7 +5488,7 @@ void R_Shadow_EditLights_Reload_f(void)
 
 void R_Shadow_EditLights_Save_f(void)
 {
-	if (!r_refdef.worldmodel)
+	if (!cl.worldmodel)
 		return;
 	R_Shadow_SaveWorldLights();
 }
@@ -4377,7 +5840,8 @@ void R_Shadow_EditLights_Edit_f(void)
 void R_Shadow_EditLights_EditAll_f(void)
 {
 	size_t lightindex;
-	dlight_t *light;
+	dlight_t *light, *oldselected;
+	size_t range;
 
 	if (!r_editlights.integer)
 	{
@@ -4385,20 +5849,25 @@ void R_Shadow_EditLights_EditAll_f(void)
 		return;
 	}
 
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	oldselected = r_shadow_selectedlight;
+	// EditLights doesn't seem to have a "remove" command or something so:
+	range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
 		R_Shadow_SelectLight(light);
 		R_Shadow_EditLights_Edit_f();
 	}
+	// return to old selected (to not mess editing once selection is locked)
+	R_Shadow_SelectLight(oldselected);
 }
 
 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
 {
 	int lightnumber, lightcount;
-	size_t lightindex;
+	size_t lightindex, range;
 	dlight_t *light;
 	float x, y;
 	char temp[256];
@@ -4409,35 +5878,36 @@ void R_Shadow_EditLights_DrawSelectedLightProperties(void)
 	DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
 	lightnumber = -1;
 	lightcount = 0;
-	for (lightindex = 0;lightindex < Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);lightindex++)
+	range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
+	for (lightindex = 0;lightindex < range;lightindex++)
 	{
-		light = Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
+		light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
 		if (!light)
 			continue;
 		if (light == r_shadow_selectedlight)
 			lightnumber = lightindex;
 		lightcount++;
 	}
-	sprintf(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;
-	sprintf(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;
+	dpsnprintf(temp, sizeof(temp), "Cursor origin: %.0f %.0f %.0f", r_editlights_cursorlocation[0], r_editlights_cursorlocation[1], r_editlights_cursorlocation[2]); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Total lights : %i active (%i total)", lightcount, (int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray)); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_DEFAULT);y += 8;
 	y += 8;
 	if (r_shadow_selectedlight == NULL)
 		return;
-	sprintf(temp, "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
-	sprintf(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;
+	dpsnprintf(temp, sizeof(temp), "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Origin       : %.0f %.0f %.0f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Angles       : %.0f %.0f %.0f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Color        : %.2f %.2f %.2f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Radius       : %.0f\n", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Corona       : %.0f\n", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Style        : %i\n", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Shadows      : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Cubemap      : %s\n", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "CoronaSize   : %.2f\n", r_shadow_selectedlight->coronasizescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Ambient      : %.2f\n", r_shadow_selectedlight->ambientscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Diffuse      : %.2f\n", r_shadow_selectedlight->diffusescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "Specular     : %.2f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "NormalMode   : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
+	dpsnprintf(temp, sizeof(temp), "RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
 }
 
 void R_Shadow_EditLights_ToggleShadow_f(void)
@@ -4501,6 +5971,7 @@ void R_Shadow_EditLights_Help_f(void)
 "r_editlights_help : this help\n"
 "r_editlights_clear : remove all lights\n"
 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
+"r_editlights_lock : lock selection to current light, if already locked - unlock\n"
 "r_editlights_save : save to .rtlights file\n"
 "r_editlights_spawn : create a light with default settings\n"
 "r_editlights_edit command : edit selected light - more documentation below\n"
@@ -4585,6 +6056,26 @@ void R_Shadow_EditLights_PasteInfo_f(void)
 	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);
 }
 
+void R_Shadow_EditLights_Lock_f(void)
+{
+	if (!r_editlights.integer)
+	{
+		Con_Print("Cannot lock on light when not in editing mode.  Set r_editlights to 1.\n");
+		return;
+	}
+	if (r_editlights_lockcursor)
+	{
+		r_editlights_lockcursor = false;
+		return;
+	}
+	if (!r_shadow_selectedlight)
+	{
+		Con_Print("No selected light to lock on.\n");
+		return;
+	}
+	r_editlights_lockcursor = true;
+}
+
 void R_Shadow_EditLights_Init(void)
 {
 	Cvar_RegisterVariable(&r_editlights);
@@ -4607,6 +6098,7 @@ void R_Shadow_EditLights_Init(void)
 	Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
 	Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
 	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)");
+	Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
 }
 
 
@@ -4624,10 +6116,10 @@ void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffu
 	VectorClear(diffusecolor);
 	VectorClear(diffusenormal);
 
-	if (!r_fullbright.integer && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
+	if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
 	{
-		ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_ambient.value * (2.0f / 128.0f);
-		r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
+		ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient;
+		r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
 	}
 	else
 		VectorSet(ambientcolor, 1, 1, 1);
@@ -4637,12 +6129,12 @@ void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffu
 		int i;
 		float f, v[3];
 		rtlight_t *light;
-		for (i = 0;i < r_refdef.numlights;i++)
+		for (i = 0;i < r_refdef.scene.numlights;i++)
 		{
-			light = &r_refdef.lights[i];
+			light = r_refdef.scene.lights[i];
 			Matrix4x4_Transform(&light->matrix_worldtolight, p, v);
 			f = 1 - VectorLength2(v);
-			if (f > 0 && CL_Move(p, vec3_origin, vec3_origin, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
+			if (f > 0 && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
 				VectorMA(ambientcolor, f, light->currentcolor, ambientcolor);
 		}
 	}