X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=r_shadow.c;h=9575f9c785c8ed8d23a7ff5146ad1661325efdb2;hp=ba4f461b8575ba8a7be0a008f5b0b2d66a9a16c9;hb=0e38741a94d0a28e659fb3a87eaa7c9464f5cb8d;hpb=c42c24d6b75aeb95fd9a8df27364042ad68df64a

diff --git a/r_shadow.c b/r_shadow.c
index ba4f461b..9575f9c7 100644
--- a/r_shadow.c
+++ b/r_shadow.c
@@ -154,9 +154,7 @@ rtexturepool_t *r_shadow_texturepool;
 rtexture_t *r_shadow_normalcubetexture;
 rtexture_t *r_shadow_attenuation2dtexture;
 rtexture_t *r_shadow_attenuation3dtexture;
-rtexture_t *r_shadow_blankbumptexture;
-rtexture_t *r_shadow_blankglosstexture;
-rtexture_t *r_shadow_blankwhitetexture;
+rtexture_t *r_shadow_blankwhitecubetexture;
 
 // lights are reloaded when this changes
 char r_shadow_mapname[MAX_QPATH];
@@ -189,6 +187,10 @@ cvar_t r_shadow_singlepassvolumegeneration = {0, "r_shadow_singlepassvolumegener
 cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"};
 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1"};
 cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0"};
+cvar_t r_shadow_glsl = {0, "r_shadow_glsl", "1"};
+cvar_t r_shadow_glsl_offsetmapping = {0, "r_shadow_glsl_offsetmapping", "1"};
+cvar_t r_shadow_glsl_offsetmapping_scale = {0, "r_shadow_glsl_offsetmapping_scale", "0.04"};
+cvar_t r_shadow_glsl_offsetmapping_bias = {0, "r_shadow_glsl_offsetmapping_bias", "-0.04"};
 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1"};
 cvar_t r_editlights = {0, "r_editlights", "0"};
 cvar_t r_editlights_cursordistance = {0, "r_editlights_distance", "1024"};
@@ -199,10 +201,6 @@ cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsi
 cvar_t r_editlights_rtlightssizescale = {CVAR_SAVE, "r_editlights_rtlightssizescale", "0.7"};
 cvar_t r_editlights_rtlightscolorscale = {CVAR_SAVE, "r_editlights_rtlightscolorscale", "2"};
 
-int c_rt_lights, c_rt_clears, c_rt_scissored;
-int c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris;
-int c_rtcached_shadowmeshes, c_rtcached_shadowtris;
-
 float r_shadow_attenpower, r_shadow_attenscale;
 
 rtlight_t *r_shadow_compilingrtlight;
@@ -226,6 +224,14 @@ cubemapinfo_t;
 static int numcubemaps;
 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
 
+#define SHADERPERMUTATION_SPECULAR (1<<0)
+#define SHADERPERMUTATION_FOG (1<<1)
+#define SHADERPERMUTATION_CUBEFILTER (1<<2)
+#define SHADERPERMUTATION_OFFSETMAPPING (1<<3)
+#define SHADERPERMUTATION_COUNT (1<<4)
+
+GLhandleARB r_shadow_program_light[SHADERPERMUTATION_COUNT];
+
 void R_Shadow_UncompileWorldLights(void);
 void R_Shadow_ClearWorldLights(void);
 void R_Shadow_SaveWorldLights(void);
@@ -237,16 +243,154 @@ void R_Shadow_ValidateCvars(void);
 static void R_Shadow_MakeTextures(void);
 void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, dlight_t *light);
 
+const char *builtinshader_light_vert =
+"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
+"// written by Forest 'LordHavoc' Hale\n"
+"\n"
+"uniform vec3 LightPosition;\n"
+"\n"
+"varying vec2 TexCoord;\n"
+"varying vec3 CubeVector;\n"
+"varying vec3 LightVector;\n"
+"\n"
+"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n"
+"uniform vec3 EyePosition;\n"
+"varying vec3 EyeVector;\n"
+"#endif\n"
+"\n"
+"// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
+"\n"
+"void main(void)\n"
+"{\n"
+"	// copy the surface texcoord\n"
+"	TexCoord = gl_MultiTexCoord0.st;\n"
+"\n"
+"	// transform vertex position into light attenuation/cubemap space\n"
+"	// (-1 to +1 across the light box)\n"
+"	CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
+"\n"
+"	// transform unnormalized light direction into tangent space\n"
+"	// (we use unnormalized to ensure that it interpolates correctly and then\n"
+"	//  normalize it per pixel)\n"
+"	vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
+"	LightVector.x = -dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
+"	LightVector.y = -dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
+"	LightVector.z = -dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
+"\n"
+"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n"
+"	// transform unnormalized eye direction into tangent space\n"
+"	vec3 eyeminusvertex = EyePosition - gl_Vertex.xyz;\n"
+"	EyeVector.x = -dot(eyeminusvertex, gl_MultiTexCoord1.xyz);\n"
+"	EyeVector.y = -dot(eyeminusvertex, gl_MultiTexCoord2.xyz);\n"
+"	EyeVector.z = -dot(eyeminusvertex, gl_MultiTexCoord3.xyz);\n"
+"#endif\n"
+"\n"
+"	// transform vertex to camera space, using ftransform to match non-VS\n"
+"	// rendering\n"
+"	gl_Position = ftransform();\n"
+"}\n"
+;
+
+const char *builtinshader_light_frag =
+"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
+"// written by Forest 'LordHavoc' Hale\n"
+"\n"
+"uniform vec3 LightColor;\n"
+"\n"
+"#ifdef USEOFFSETMAPPING\n"
+"uniform float OffsetMapping_Scale;\n"
+"uniform float OffsetMapping_Bias;\n"
+"#endif\n"
+"#ifdef USESPECULAR\n"
+"uniform float SpecularPower;\n"
+"#endif\n"
+"#ifdef USEFOG\n"
+"uniform float FogRangeRecip;\n"
+"#endif\n"
+"uniform float AmbientScale;\n"
+"uniform float DiffuseScale;\n"
+"#ifdef USESPECULAR\n"
+"uniform float SpecularScale;\n"
+"#endif\n"
+"\n"
+"uniform sampler2D Texture_Normal;\n"
+"uniform sampler2D Texture_Color;\n"
+"#ifdef USESPECULAR\n"
+"uniform sampler2D Texture_Gloss;\n"
+"#endif\n"
+"#ifdef USECUBEFILTER\n"
+"uniform samplerCube Texture_Cube;\n"
+"#endif\n"
+"#ifdef USEFOG\n"
+"uniform sampler2D Texture_FogMask;\n"
+"#endif\n"
+"\n"
+"varying vec2 TexCoord;\n"
+"varying vec3 CubeVector;\n"
+"varying vec3 LightVector;\n"
+"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n"
+"varying vec3 EyeVector;\n"
+"#endif\n"
+"\n"
+"void main(void)\n"
+"{\n"
+"	// attenuation\n"
+"	//\n"
+"	// the attenuation is (1-(x*x+y*y+z*z)) which gives a large bright\n"
+"	// center and sharp falloff at the edge, this is about the most efficient\n"
+"	// we can get away with as far as providing illumination.\n"
+"	//\n"
+"	// pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n"
+"	// provide significant illumination, large = slow = pain.\n"
+"	float colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
+"\n"
+"#ifdef USEFOG\n"
+"	// apply fog\n"
+"	colorscale *= texture2D(Texture_FogMask, vec2(length(EyeVector)*FogRangeRecip, 0)).x;\n"
+"#endif\n"
+"\n"
+"#ifdef USEOFFSETMAPPING\n"
+"	// this is 3 sample because of ATI Radeon 9500-9800/X300 limits\n"
+"	vec2 OffsetVector = normalize(EyeVector).xy * vec2(-0.333, 0.333);\n"
+"	vec2 TexCoordOffset = TexCoord + OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).w);\n"
+"	TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
+"	TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
+"#define TexCoord TexCoordOffset\n"
+"#endif\n"
+"\n"
+"	// get the texels - with a blendmap we'd need to blend multiple here\n"
+"	vec3 surfacenormal = -1.0 + 2.0 * vec3(texture2D(Texture_Normal, TexCoord));\n"
+"	vec3 colortexel = vec3(texture2D(Texture_Color, TexCoord));\n"
+"#ifdef USESPECULAR\n"
+"	vec3 glosstexel = vec3(texture2D(Texture_Gloss, TexCoord));\n"
+"#endif\n"
+"\n"
+"	// calculate shading\n"
+"	vec3 diffusenormal = normalize(LightVector);\n"
+"	vec3 color = colortexel * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
+"#ifdef USESPECULAR\n"
+"	color += glosstexel * (SpecularScale * pow(max(dot(surfacenormal, normalize(diffusenormal + normalize(EyeVector))), 0.0), SpecularPower));\n"
+"#endif\n"
+"\n"
+"#ifdef USECUBEFILTER\n"
+"	// apply light cubemap filter\n"
+"	color *= vec3(textureCube(Texture_Cube, CubeVector));\n"
+"#endif\n"
+"\n"
+"	// calculate fragment color\n"
+"	gl_FragColor = vec4(LightColor * color * colorscale, 1);\n"
+"}\n"
+;
+
 void r_shadow_start(void)
 {
+	int i;
 	// allocate vertex processing arrays
 	numcubemaps = 0;
 	r_shadow_normalcubetexture = NULL;
 	r_shadow_attenuation2dtexture = NULL;
 	r_shadow_attenuation3dtexture = NULL;
-	r_shadow_blankbumptexture = NULL;
-	r_shadow_blankglosstexture = NULL;
-	r_shadow_blankwhitetexture = NULL;
+	r_shadow_blankwhitecubetexture = NULL;
 	r_shadow_texturepool = NULL;
 	r_shadow_filters_texturepool = NULL;
 	R_Shadow_ValidateCvars();
@@ -268,18 +412,90 @@ void r_shadow_start(void)
 	r_shadow_buffer_numsurfacepvsbytes = 0;
 	r_shadow_buffer_surfacepvs = NULL;
 	r_shadow_buffer_surfacelist = NULL;
+	for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
+		r_shadow_program_light[i] = 0;
+	if (gl_support_fragment_shader)
+	{
+		char *vertstring, *fragstring;
+		int vertstrings_count;
+		int fragstrings_count;
+		const char *vertstrings_list[SHADERPERMUTATION_COUNT];
+		const char *fragstrings_list[SHADERPERMUTATION_COUNT];
+		vertstring = FS_LoadFile("glsl/light.vert", tempmempool, false);
+		fragstring = FS_LoadFile("glsl/light.frag", tempmempool, false);
+		for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
+		{
+			vertstrings_count = 0;
+			fragstrings_count = 0;
+			if (i & SHADERPERMUTATION_SPECULAR)
+			{
+				vertstrings_list[vertstrings_count++] = "#define USESPECULAR\n";
+				fragstrings_list[fragstrings_count++] = "#define USESPECULAR\n";
+			}
+			if (i & SHADERPERMUTATION_FOG)
+			{
+				vertstrings_list[vertstrings_count++] = "#define USEFOG\n";
+				fragstrings_list[fragstrings_count++] = "#define USEFOG\n";
+			}
+			if (i & SHADERPERMUTATION_CUBEFILTER)
+			{
+				vertstrings_list[vertstrings_count++] = "#define USECUBEFILTER\n";
+				fragstrings_list[fragstrings_count++] = "#define USECUBEFILTER\n";
+			}
+			if (i & SHADERPERMUTATION_OFFSETMAPPING)
+			{
+				vertstrings_list[vertstrings_count++] = "#define USEOFFSETMAPPING\n";
+				fragstrings_list[fragstrings_count++] = "#define USEOFFSETMAPPING\n";
+			}
+			vertstrings_list[vertstrings_count++] = vertstring ? vertstring : builtinshader_light_vert;
+			fragstrings_list[fragstrings_count++] = fragstring ? fragstring : builtinshader_light_frag;
+			r_shadow_program_light[i] = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, fragstrings_count, fragstrings_list);
+			if (!r_shadow_program_light[i])
+			{
+				Con_Printf("permutation %s %s %s %s failed for shader %s, some features may not work properly!\n", i & 1 ? "specular" : "", i & 2 ? "fog" : "", i & 4 ? "cubefilter" : "", i & 8 ? "offsetmapping" : "", "glsl/light");
+				continue;
+			}
+			qglUseProgramObjectARB(r_shadow_program_light[i]);
+			qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Normal"), 0);CHECKGLERROR
+			qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Color"), 1);CHECKGLERROR
+			if (i & SHADERPERMUTATION_SPECULAR)
+			{
+				qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Gloss"), 2);CHECKGLERROR
+			}
+			if (i & SHADERPERMUTATION_CUBEFILTER)
+			{
+				qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Cube"), 3);CHECKGLERROR
+			}
+			if (i & SHADERPERMUTATION_FOG)
+			{
+				qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_FogMask"), 4);CHECKGLERROR
+			}
+		}
+		qglUseProgramObjectARB(0);
+		if (fragstring)
+			Mem_Free(fragstring);
+		if (vertstring)
+			Mem_Free(vertstring);
+	}
 }
 
 void r_shadow_shutdown(void)
 {
+	int i;
 	R_Shadow_UncompileWorldLights();
+	for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
+	{
+		if (r_shadow_program_light[i])
+		{
+			GL_Backend_FreeProgram(r_shadow_program_light[i]);
+			r_shadow_program_light[i] = 0;
+		}
+	}
 	numcubemaps = 0;
 	r_shadow_normalcubetexture = NULL;
 	r_shadow_attenuation2dtexture = NULL;
 	r_shadow_attenuation3dtexture = NULL;
-	r_shadow_blankbumptexture = NULL;
-	r_shadow_blankglosstexture = NULL;
-	r_shadow_blankwhitetexture = NULL;
+	r_shadow_blankwhitecubetexture = NULL;
 	R_FreeTexturePool(&r_shadow_texturepool);
 	R_FreeTexturePool(&r_shadow_filters_texturepool);
 	maxshadowelements = 0;
@@ -345,6 +561,10 @@ void R_Shadow_Help_f(void)
 "r_shadow_realtime_world_dlightshadows : cast shadows from dlights\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_glsl : use OpenGL Shading Language for lighting\n"
+"r_shadow_glsl_offsetmapping : enables Offset Mapping bumpmap enhancement\n"
+"r_shadow_glsl_offsetmapping_scale : controls depth of Offset Mapping\n"
+"r_shadow_glsl_offsetmapping_bias : should be negative half of scale\n"
 "r_shadow_scissor : use scissor optimization\n"
 "r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n"
 "r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n"
@@ -383,6 +603,10 @@ void R_Shadow_Init(void)
 	Cvar_RegisterVariable(&r_shadow_staticworldlights);
 	Cvar_RegisterVariable(&r_shadow_texture3d);
 	Cvar_RegisterVariable(&r_shadow_visiblevolumes);
+	Cvar_RegisterVariable(&r_shadow_glsl);
+	Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping);
+	Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_scale);
+	Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_bias);
 	Cvar_RegisterVariable(&gl_ext_stenciltwoside);
 	if (gamemode == GAME_TENEBRAE)
 	{
@@ -502,10 +726,10 @@ void R_Shadow_PrepareShadowMark(int numtris)
 
 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, float projectdistance, int numshadowmarktris, const int *shadowmarktris)
 {
-	int i, j, tris = 0, vr[3], t, outvertices = 0;
-	float f, temp[3];
-	const int *e, *n;
-	const float *v;
+	int i, j;
+	int outtriangles = 0, outvertices = 0;
+	const int *element;
+	const float *vertex;
 
 	if (maxvertexupdate < innumvertices)
 	{
@@ -525,28 +749,28 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 		memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
 		memset(vertexremap, 0, maxvertexupdate * sizeof(int));
 	}
-	
+
 	for (i = 0;i < numshadowmarktris;i++)
 		shadowmark[shadowmarktris[i]] = shadowmarkcount;
 
 	for (i = 0;i < numshadowmarktris;i++)
 	{
-		t = shadowmarktris[i];
-		e = inelement3i + t * 3;
+		element = inelement3i + shadowmarktris[i] * 3;
 		// make sure the vertices are created
 		for (j = 0;j < 3;j++)
 		{
-			if (vertexupdate[e[j]] != vertexupdatenum)
+			if (vertexupdate[element[j]] != vertexupdatenum)
 			{
-				vertexupdate[e[j]] = vertexupdatenum;
-				vertexremap[e[j]] = outvertices;
-				v = invertex3f + e[j] * 3;
+				float ratio, direction[3];
+				vertexupdate[element[j]] = vertexupdatenum;
+				vertexremap[element[j]] = outvertices;
+				vertex = invertex3f + element[j] * 3;
 				// project one copy of the vertex to the sphere radius of the light
 				// (FIXME: would projecting it to the light box be better?)
-				VectorSubtract(v, projectorigin, temp);
-				f = projectdistance / VectorLength(temp);
-				VectorCopy(v, outvertex3f);
-				VectorMA(projectorigin, f, temp, (outvertex3f + 3));
+				VectorSubtract(vertex, projectorigin, direction);
+				ratio = projectdistance / VectorLength(direction);
+				VectorCopy(vertex, outvertex3f);
+				VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
 				outvertex3f += 6;
 				outvertices += 2;
 			}
@@ -555,62 +779,70 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 
 	for (i = 0;i < numshadowmarktris;i++)
 	{
-		t = shadowmarktris[i];
-		e = inelement3i + t * 3;
-		n = inneighbor3i + t * 3;
+		int remappedelement[3];
+		int markindex;
+		const int *neighbortriangle;
+
+		markindex = shadowmarktris[i] * 3;
+		element = inelement3i + markindex;
+		neighbortriangle = inneighbor3i + markindex;
 		// output the front and back triangles
-		outelement3i[0] = vertexremap[e[0]];
-		outelement3i[1] = vertexremap[e[1]];
-		outelement3i[2] = vertexremap[e[2]];
-		outelement3i[3] = vertexremap[e[2]] + 1;
-		outelement3i[4] = vertexremap[e[1]] + 1;
-		outelement3i[5] = vertexremap[e[0]] + 1;
+		outelement3i[0] = vertexremap[element[0]];
+		outelement3i[1] = vertexremap[element[1]];
+		outelement3i[2] = vertexremap[element[2]];
+		outelement3i[3] = vertexremap[element[2]] + 1;
+		outelement3i[4] = vertexremap[element[1]] + 1;
+		outelement3i[5] = vertexremap[element[0]] + 1;
+
 		outelement3i += 6;
-		tris += 2;
+		outtriangles += 2;
 		// output the sides (facing outward from this triangle)
-		if (shadowmark[n[0]] != shadowmarkcount)
-		{
-			vr[0] = vertexremap[e[0]];
-			vr[1] = vertexremap[e[1]];
-			outelement3i[0] = vr[1];
-			outelement3i[1] = vr[0];
-			outelement3i[2] = vr[0] + 1;
-			outelement3i[3] = vr[1];
-			outelement3i[4] = vr[0] + 1;
-			outelement3i[5] = vr[1] + 1;
+		if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
+		{
+			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;
-			tris += 2;
-		}
-		if (shadowmark[n[1]] != shadowmarkcount)
-		{
-			vr[1] = vertexremap[e[1]];
-			vr[2] = vertexremap[e[2]];
-			outelement3i[0] = vr[2];
-			outelement3i[1] = vr[1];
-			outelement3i[2] = vr[1] + 1;
-			outelement3i[3] = vr[2];
-			outelement3i[4] = vr[1] + 1;
-			outelement3i[5] = vr[2] + 1;
+			outtriangles += 2;
+		}
+		if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
+		{
+			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;
-			tris += 2;
-		}
-		if (shadowmark[n[2]] != shadowmarkcount)
-		{
-			vr[0] = vertexremap[e[0]];
-			vr[2] = vertexremap[e[2]];
-			outelement3i[0] = vr[0];
-			outelement3i[1] = vr[2];
-			outelement3i[2] = vr[2] + 1;
-			outelement3i[3] = vr[0];
-			outelement3i[4] = vr[2] + 1;
-			outelement3i[5] = vr[0] + 1;
+			outtriangles += 2;
+		}
+		if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
+		{
+			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;
-			tris += 2;
+			outtriangles += 2;
 		}
 	}
 	if (outnumvertices)
 		*outnumvertices = outvertices;
-	return tris;
+	return outtriangles;
 }
 
 void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, int nummarktris, const int *marktris)
@@ -630,7 +862,7 @@ void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f,
 	R_Shadow_RenderVolume(outverts, tris, varray_vertex3f2, shadowelements);
 }
 
-void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, vec3_t lightmins, vec3_t lightmaxs, vec3_t surfacemins, vec3_t surfacemaxs)
+void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs)
 {
 	int t, tend;
 	const int *e;
@@ -685,14 +917,14 @@ void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *verte
 		// increment stencil if backface is behind depthbuffer
 		qglCullFace(GL_BACK); // quake is backwards, this culls front faces
 		qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
-		R_Mesh_Draw(numvertices, numtriangles, element3i);
+		R_Mesh_Draw(0, numvertices, numtriangles, element3i);
 		c_rt_shadowmeshes++;
 		c_rt_shadowtris += numtriangles;
 		// decrement stencil if frontface is behind depthbuffer
 		qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
 		qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
 	}
-	R_Mesh_Draw(numvertices, numtriangles, element3i);
+	R_Mesh_Draw(0, numvertices, numtriangles, element3i);
 	c_rt_shadowmeshes++;
 	c_rt_shadowtris += numtriangles;
 	GL_LockArrays(0, 0);
@@ -711,23 +943,17 @@ static void R_Shadow_MakeTextures(void)
 #define ATTEN2DSIZE 64
 #define ATTEN3DSIZE 32
 	data = Mem_Alloc(tempmempool, max(6*NORMSIZE*NORMSIZE*4, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4)));
-	data[0] = 128;
-	data[1] = 128;
-	data[2] = 255;
-	data[3] = 255;
-	r_shadow_blankbumptexture = R_LoadTexture2D(r_shadow_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
-	data[0] = 255;
-	data[1] = 255;
-	data[2] = 255;
-	data[3] = 255;
-	r_shadow_blankglosstexture = R_LoadTexture2D(r_shadow_texturepool, "blankgloss", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
-	data[0] = 255;
-	data[1] = 255;
-	data[2] = 255;
-	data[3] = 255;
-	r_shadow_blankwhitetexture = R_LoadTexture2D(r_shadow_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+	r_shadow_blankwhitecubetexture = NULL;
+	r_shadow_normalcubetexture = NULL;
 	if (gl_texturecubemap)
 	{
+		data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255;
+		data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255;
+		data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255;
+		data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255;
+		data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255;
+		data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255;
+		r_shadow_blankwhitecubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "blankwhitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
 		for (side = 0;side < 6;side++)
 		{
 			for (y = 0;y < NORMSIZE;y++)
@@ -779,8 +1005,6 @@ static void R_Shadow_MakeTextures(void)
 		}
 		r_shadow_normalcubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
 	}
-	else
-		r_shadow_normalcubetexture = NULL;
 	for (y = 0;y < ATTEN2DSIZE;y++)
 	{
 		for (x = 0;x < ATTEN2DSIZE;x++)
@@ -856,10 +1080,6 @@ void R_Shadow_Stage_Begin(void)
 	qglEnable(GL_CULL_FACE);
 	GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
 	r_shadowstage = SHADOWSTAGE_NONE;
-
-	c_rt_lights = c_rt_clears = c_rt_scissored = 0;
-	c_rt_shadowmeshes = c_rt_shadowtris = c_rt_lightmeshes = c_rt_lighttris = 0;
-	c_rtcached_shadowmeshes = c_rtcached_shadowtris = 0;
 }
 
 void R_Shadow_Stage_ShadowVolumes(void)
@@ -1337,19 +1557,111 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 	int renders;
 	float color[3], color2[3], colorscale;
 	rmeshstate_t m;
-	if (!bumptexture)
-		bumptexture = r_shadow_blankbumptexture;
-	if (!glosstexture)
-		glosstexture = r_shadow_blankglosstexture;
 	// FIXME: support EF_NODEPTHTEST
 	GL_DepthMask(false);
 	GL_DepthTest(true);
-	if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil)
+	if (!bumptexture)
+		bumptexture = r_texture_blanknormalmap;
+	specularscale *= r_shadow_glossintensity.value;
+	if (!glosstexture)
+	{
+		if (r_shadow_gloss.integer >= 2)
+		{
+			glosstexture = r_texture_white;
+			specularscale *= r_shadow_gloss2intensity.value;
+		}
+		else
+		{
+			glosstexture = r_texture_black;
+			specularscale = 0;
+		}
+	}
+	if (r_shadow_gloss.integer < 1)
+		specularscale = 0;
+	if (!lightcubemap)
+		lightcubemap = r_shadow_blankwhitecubetexture;
+	if (ambientscale + diffusescale + specularscale < 0.01)
+		return;
+	if (r_shadow_glsl.integer && r_shadow_program_light[0])
+	{
+		unsigned int perm, prog;
+		// GLSL shader path (GFFX5200, Radeon 9500)
+		memset(&m, 0, sizeof(m));
+		m.pointer_vertex = vertex3f;
+		m.pointer_texcoord[0] = texcoord2f;
+		m.pointer_texcoord3f[1] = svector3f;
+		m.pointer_texcoord3f[2] = tvector3f;
+		m.pointer_texcoord3f[3] = normal3f;
+		m.tex[0] = R_GetTexture(bumptexture);
+		m.tex[1] = R_GetTexture(basetexture);
+		m.tex[2] = R_GetTexture(glosstexture);
+		m.texcubemap[3] = R_GetTexture(lightcubemap);
+		// TODO: support fog (after renderer is converted to texture fog)
+		m.tex[4] = R_GetTexture(r_texture_white);
+		m.texmatrix[3] = *matrix_modeltolight;
+		R_Mesh_State(&m);
+		GL_BlendFunc(GL_ONE, GL_ONE);
+		GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
+		CHECKGLERROR
+		perm = 0;
+		// only add a feature to the permutation if that permutation exists
+		// (otherwise it might end up not using a shader at all, which looks
+		// worse than using less features)
+		if (specularscale && r_shadow_program_light[perm | SHADERPERMUTATION_SPECULAR])
+			perm |= SHADERPERMUTATION_SPECULAR;
+		//if (fog && r_shadow_program_light[perm | SHADERPERMUTATION_FOG])
+		//	perm |= SHADERPERMUTATION_FOG;
+		if (lightcubemap && r_shadow_program_light[perm | SHADERPERMUTATION_CUBEFILTER])
+			perm |= SHADERPERMUTATION_CUBEFILTER;
+		if (r_shadow_glsl_offsetmapping.integer && r_shadow_program_light[perm | SHADERPERMUTATION_OFFSETMAPPING])
+			perm |= SHADERPERMUTATION_OFFSETMAPPING;
+		prog = r_shadow_program_light[perm];
+		qglUseProgramObjectARB(prog);CHECKGLERROR
+		// TODO: support fog (after renderer is converted to texture fog)
+		if (perm & SHADERPERMUTATION_FOG)
+		{
+			qglUniform1fARB(qglGetUniformLocationARB(prog, "FogRangeRecip"), 0);CHECKGLERROR
+		}
+		qglUniform1fARB(qglGetUniformLocationARB(prog, "AmbientScale"), ambientscale);CHECKGLERROR
+		qglUniform1fARB(qglGetUniformLocationARB(prog, "DiffuseScale"), diffusescale);CHECKGLERROR
+		if (perm & SHADERPERMUTATION_SPECULAR)
+		{
+			qglUniform1fARB(qglGetUniformLocationARB(prog, "SpecularPower"), 8);CHECKGLERROR
+			qglUniform1fARB(qglGetUniformLocationARB(prog, "SpecularScale"), specularscale);CHECKGLERROR
+		}
+		qglUniform3fARB(qglGetUniformLocationARB(prog, "LightColor"), lightcolor[0], lightcolor[1], lightcolor[2]);CHECKGLERROR
+		qglUniform3fARB(qglGetUniformLocationARB(prog, "LightPosition"), relativelightorigin[0], relativelightorigin[1], relativelightorigin[2]);CHECKGLERROR
+		if (perm & (SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_FOG | SHADERPERMUTATION_OFFSETMAPPING))
+		{
+			qglUniform3fARB(qglGetUniformLocationARB(prog, "EyePosition"), relativeeyeorigin[0], relativeeyeorigin[1], relativeeyeorigin[2]);CHECKGLERROR
+		}
+		if (perm & SHADERPERMUTATION_OFFSETMAPPING)
+		{
+			qglUniform1fARB(qglGetUniformLocationARB(prog, "OffsetMapping_Scale"), r_shadow_glsl_offsetmapping_scale.value);CHECKGLERROR
+			qglUniform1fARB(qglGetUniformLocationARB(prog, "OffsetMapping_Bias"), r_shadow_glsl_offsetmapping_bias.value);CHECKGLERROR
+		}
+		CHECKGLERROR
+		GL_LockArrays(0, numverts);
+		R_Mesh_Draw(0, numverts, numtriangles, elements);
+		c_rt_lightmeshes++;
+		c_rt_lighttris += numtriangles;
+		GL_LockArrays(0, 0);
+		qglUseProgramObjectARB(0);
+		// HACK HACK HACK: work around for stupid NVIDIA bug that causes GL_OUT_OF_MEMORY and/or software rendering
+		qglBegin(GL_TRIANGLES);
+		qglEnd();
+		CHECKGLERROR
+	}
+	else if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil)
 	{
+		if (!bumptexture)
+			bumptexture = r_texture_blanknormalmap;
+		if (!glosstexture)
+			glosstexture = r_texture_white;
 		if (ambientscale)
 		{
 			GL_Color(1,1,1,1);
-			colorscale = r_shadow_lightintensityscale.value * ambientscale;
+			colorscale = ambientscale;
 			// colorscale accounts for how much we multiply the brightness
 			// during combine.
 			//
@@ -1380,6 +1692,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				m.pointer_texcoord3f[2] = varray_texcoord3f[2];
 				R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltolight);
 #endif
+				GL_BlendFunc(GL_ONE, GL_ONE);
 			}
 			else if (r_shadow_texture3d.integer && !lightcubemap && r_textureunits.integer >= 2)
 			{
@@ -1396,6 +1709,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 #endif
 				m.tex[1] = R_GetTexture(basetexture);
 				m.pointer_texcoord[1] = texcoord2f;
+				GL_BlendFunc(GL_ONE, GL_ONE);
 			}
 			else if (r_textureunits.integer >= 4 && lightcubemap)
 			{
@@ -1431,6 +1745,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[3], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_ONE, GL_ONE);
 			}
 			else if (r_textureunits.integer >= 3 && !lightcubemap)
 			{
@@ -1455,6 +1770,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 #endif
 				m.tex[2] = R_GetTexture(basetexture);
 				m.pointer_texcoord[2] = texcoord2f;
+				GL_BlendFunc(GL_ONE, GL_ONE);
 			}
 			else
 			{
@@ -1481,11 +1797,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1501,26 +1817,26 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			// this final code is shared
 			R_Mesh_State(&m);
 			GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
-			GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			VectorScale(lightcolor, colorscale, color2);
+			GL_LockArrays(0, numverts);
 			for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
 			{
 				GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
-				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
-				GL_LockArrays(0, 0);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
 			}
+			GL_LockArrays(0, 0);
 		}
 		if (diffusescale)
 		{
 			GL_Color(1,1,1,1);
-			colorscale = r_shadow_lightintensityscale.value * diffusescale;
+			colorscale = diffusescale;
 			// colorscale accounts for how much we multiply the brightness
 			// during combine.
 			//
@@ -1552,11 +1868,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1572,6 +1888,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap)
 			{
@@ -1590,11 +1907,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(bumptexture);
@@ -1607,11 +1924,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				R_Mesh_State(&m);
 				GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1627,6 +1944,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap)
 			{
@@ -1644,11 +1962,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1661,6 +1979,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				m.pointer_texcoord3f[1] = varray_texcoord3f[1];
 				R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
 #endif
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			else if (r_textureunits.integer >= 4)
 			{
@@ -1694,11 +2013,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1714,6 +2033,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			else
 			{
@@ -1740,11 +2060,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				GL_ColorMask(0,0,0,1);
 				GL_BlendFunc(GL_ONE, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(bumptexture);
@@ -1757,11 +2077,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				R_Mesh_State(&m);
 				GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
-	
+
 				memset(&m, 0, sizeof(m));
 				m.pointer_vertex = vertex3f;
 				m.tex[0] = R_GetTexture(basetexture);
@@ -1777,30 +2097,28 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 				}
+				GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			}
 			// this final code is shared
 			R_Mesh_State(&m);
 			GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
-			GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 			VectorScale(lightcolor, colorscale, color2);
+			GL_LockArrays(0, numverts);
 			for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
 			{
 				GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
-				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
-				GL_LockArrays(0, 0);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
 			}
+			GL_LockArrays(0, 0);
 		}
-		if (specularscale && (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture)))
+		if (specularscale && glosstexture != r_texture_black)
 		{
 			// FIXME: detect blendsquare!
 			//if (gl_support_blendsquare)
 			{
-				colorscale = r_shadow_lightintensityscale.value * r_shadow_glossintensity.value * specularscale;
-				if (glosstexture == r_shadow_blankglosstexture)
-					colorscale *= r_shadow_gloss2intensity.value;
+				colorscale = specularscale;
 				GL_Color(1,1,1,1);
 				if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare!
 				{
@@ -1818,11 +2136,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// this squares the result
 					GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
 					GL_LockArrays(0, numverts);
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					GL_LockArrays(0, 0);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					R_Mesh_State(&m);
@@ -1833,14 +2151,14 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
 					// 0.25 * 0.25 = 0.0625 (this is another pass)
 					// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
 					GL_LockArrays(0, 0);
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
@@ -1854,11 +2172,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Mesh_State(&m);
 					GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
 					GL_LockArrays(0, numverts);
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					GL_LockArrays(0, 0);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					m.tex[0] = R_GetTexture(glosstexture);
@@ -1874,6 +2192,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 						R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 					}
+					GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 				}
 				else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare!
 				{
@@ -1891,11 +2210,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// this squares the result
 					GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
 					GL_LockArrays(0, numverts);
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					GL_LockArrays(0, 0);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					R_Mesh_State(&m);
@@ -1906,14 +2225,14 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
 					// 0.25 * 0.25 = 0.0625 (this is another pass)
 					// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
 					GL_LockArrays(0, 0);
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					m.tex[0] = R_GetTexture(glosstexture);
@@ -1926,6 +2245,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					m.pointer_texcoord3f[1] = varray_texcoord3f[1];
 					R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
 #endif
+					GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 				}
 				else
 				{
@@ -1943,11 +2263,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// this squares the result
 					GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
 					GL_LockArrays(0, numverts);
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					GL_LockArrays(0, 0);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					R_Mesh_State(&m);
@@ -1958,14 +2278,14 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					// 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
 					// 0.25 * 0.25 = 0.0625 (this is another pass)
 					// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
 					GL_LockArrays(0, 0);
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
@@ -1987,11 +2307,11 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 					R_Mesh_State(&m);
 					GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
 					GL_LockArrays(0, numverts);
-					R_Mesh_Draw(numverts, numtriangles, elements);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
 					GL_LockArrays(0, 0);
 					c_rt_lightmeshes++;
 					c_rt_lighttris += numtriangles;
-		
+
 					memset(&m, 0, sizeof(m));
 					m.pointer_vertex = vertex3f;
 					m.tex[0] = R_GetTexture(glosstexture);
@@ -2007,29 +2327,29 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 						R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
 #endif
 					}
+					GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
 				}
+				R_Mesh_State(&m);
+				GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
+				VectorScale(lightcolor, colorscale, color2);
+				GL_LockArrays(0, numverts);
+				for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
+				{
+					GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
+					R_Mesh_Draw(0, numverts, numtriangles, elements);
+					c_rt_lightmeshes++;
+					c_rt_lighttris += numtriangles;
+				}
+				GL_LockArrays(0, 0);
 			}
-			R_Mesh_State(&m);
-			GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
-			GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
-			VectorScale(lightcolor, colorscale, color2);
-			GL_LockArrays(0, numverts);
-			for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
-			{
-				GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
-				R_Mesh_Draw(numverts, numtriangles, elements);
-				c_rt_lightmeshes++;
-				c_rt_lighttris += numtriangles;
-			}
-			GL_LockArrays(0, 0);
 		}
 	}
 	else
 	{
 		if (ambientscale)
 		{
-			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-			VectorScale(lightcolor, r_shadow_lightintensityscale.value * ambientscale, color2);
+			GL_BlendFunc(GL_ONE, GL_ONE);
+			VectorScale(lightcolor, ambientscale, color2);
 			memset(&m, 0, sizeof(m));
 			m.pointer_vertex = vertex3f;
 			m.tex[0] = R_GetTexture(basetexture);
@@ -2058,6 +2378,10 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 #endif
 				}
 			}
+			if (r_textureunits.integer >= 3)
+				m.pointer_color = NULL;
+			else
+				m.pointer_color = varray_color4f;
 			R_Mesh_State(&m);
 			for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
 			{
@@ -2065,22 +2389,13 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				color[1] = bound(0, color2[1], 1);
 				color[2] = bound(0, color2[2], 1);
 				if (r_textureunits.integer >= 3)
-				{
 					GL_Color(color[0], color[1], color[2], 1);
-					m.pointer_color = NULL;
-				}
 				else if (r_textureunits.integer >= 2)
-				{
 					R_Shadow_VertexNoShadingWithZAttenuation(numverts, vertex3f, color, matrix_modeltolight);
-					m.pointer_color = varray_color4f;
-				}
 				else
-				{
 					R_Shadow_VertexNoShadingWithXYZAttenuation(numverts, vertex3f, color, matrix_modeltolight);
-					m.pointer_color = varray_color4f;
-				}
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
@@ -2088,8 +2403,8 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 		}
 		if (diffusescale)
 		{
-			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-			VectorScale(lightcolor, r_shadow_lightintensityscale.value * diffusescale, color2);
+			GL_BlendFunc(GL_ONE, GL_ONE);
+			VectorScale(lightcolor, diffusescale, color2);
 			memset(&m, 0, sizeof(m));
 			m.pointer_vertex = vertex3f;
 			m.pointer_color = varray_color4f;
@@ -2132,7 +2447,7 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements
 				else
 					R_Shadow_VertexShadingWithXYZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight);
 				GL_LockArrays(0, numverts);
-				R_Mesh_Draw(numverts, numtriangles, elements);
+				R_Mesh_Draw(0, numverts, numtriangles, elements);
 				GL_LockArrays(0, 0);
 				c_rt_lightmeshes++;
 				c_rt_lighttris += numtriangles;
@@ -2194,8 +2509,8 @@ void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int i
 void R_RTLight_Compile(rtlight_t *rtlight)
 {
 	int shadowmeshes, shadowtris, lightmeshes, lighttris, numclusters, numsurfaces;
-	entity_render_t *ent = &cl_entities[0].render;
-	model_t *model = ent->model;
+	entity_render_t *ent = r_refdef.worldentity;
+	model_t *model = r_refdef.worldmodel;
 
 	// compile the light
 	rtlight->compiled = true;
@@ -2215,21 +2530,21 @@ void R_RTLight_Compile(rtlight_t *rtlight)
 		// this variable directs the DrawShadowVolume and DrawLight code to capture into the mesh chain instead of rendering
 		r_shadow_compilingrtlight = rtlight;
 		R_Shadow_EnlargeClusterBuffer(model->brush.num_pvsclusters);
-		R_Shadow_EnlargeSurfaceBuffer(model->nummodelsurfaces); 
+		R_Shadow_EnlargeSurfaceBuffer(model->nummodelsurfaces);
 		model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
+		rtlight->static_numclusterpvsbytes = (model->brush.num_pvsclusters + 7) >> 3;
+		rtlight->static_clusterpvs = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusterpvsbytes);
 		if (numclusters)
 		{
 			rtlight->static_numclusters = numclusters;
-			rtlight->static_numclusterpvsbytes = (model->brush.num_pvsclusters + 7) >> 3;
 			rtlight->static_clusterlist = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist));
-			rtlight->static_clusterpvs = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusterpvsbytes);
 			memcpy(rtlight->static_clusterlist, r_shadow_buffer_clusterlist, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist));
 			memcpy(rtlight->static_clusterpvs, r_shadow_buffer_clusterpvs, rtlight->static_numclusterpvsbytes);
 		}
 		if (model->DrawShadowVolume && rtlight->shadow)
 		{
 			rtlight->static_meshchain_shadow = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, false, false, true);
-			model->DrawShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
+			model->DrawShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist, rtlight->cullmins, rtlight->cullmaxs);
 			rtlight->static_meshchain_shadow = Mod_ShadowMesh_Finish(r_shadow_mempool, rtlight->static_meshchain_shadow, false, false);
 		}
 		if (model->DrawLight)
@@ -2305,7 +2620,7 @@ void R_Shadow_UncompileWorldLights(void)
 
 void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 {
-	int i, shadow;
+	int i, shadow, usestencil;
 	entity_render_t *ent;
 	float f;
 	vec3_t relativelightorigin, relativeeyeorigin, lightcolor, lightcolor2;
@@ -2314,10 +2629,26 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 	int numclusters, numsurfaces;
 	int *clusterlist, *surfacelist;
 	qbyte *clusterpvs;
-	vec3_t cullmins, cullmaxs;
+	vec3_t cullmins, cullmaxs, relativelightmins, relativelightmaxs;
 	shadowmesh_t *mesh;
 	rmeshstate_t m;
 
+	// skip lights that don't light (corona only lights)
+	if (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale < 0.01)
+		return;
+
+	f = (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value;
+	VectorScale(rtlight->color, f, lightcolor);
+	if (VectorLength2(lightcolor) < 0.01)
+		return;
+	/*
+	if (rtlight->selected)
+	{
+		f = 2 + sin(realtime * M_PI * 4.0);
+		VectorScale(lightcolor, f, lightcolor);
+	}
+	*/
+
 	// 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)
@@ -2351,16 +2682,16 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 		VectorCopy(rtlight->cullmins, cullmins);
 		VectorCopy(rtlight->cullmaxs, cullmaxs);
 	}
-	else if (cl.worldmodel && cl.worldmodel->GetLightInfo)
+	else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo)
 	{
 		// dynamic light, world available and can receive realtime lighting
 		// if the light box is offscreen, skip it right away
 		if (R_CullBox(cullmins, cullmaxs))
 			return;
 		// calculate lit surfaces and clusters
-		R_Shadow_EnlargeClusterBuffer(cl.worldmodel->brush.num_pvsclusters);
-		R_Shadow_EnlargeSurfaceBuffer(cl.worldmodel->nummodelsurfaces); 
-		cl.worldmodel->GetLightInfo(&cl_entities[0].render, rtlight->shadoworigin, rtlight->radius, cullmins, cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
+		R_Shadow_EnlargeClusterBuffer(r_refdef.worldmodel->brush.num_pvsclusters);
+		R_Shadow_EnlargeSurfaceBuffer(r_refdef.worldmodel->nummodelsurfaces);
+		r_refdef.worldmodel->GetLightInfo(&cl_entities[0].render, rtlight->shadoworigin, rtlight->radius, cullmins, cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
 		clusterlist = r_shadow_buffer_clusterlist;
 		clusterpvs = r_shadow_buffer_clusterpvs;
 		surfacelist = r_shadow_buffer_surfacelist;
@@ -2381,22 +2712,16 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 	if (R_Shadow_ScissorForBBox(cullmins, cullmaxs))
 		return;
 
-	f = (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f);
-	VectorScale(rtlight->color, f, lightcolor);
-	/*
-	if (rtlight->selected)
-	{
-		f = 2 + sin(realtime * M_PI * 4.0);
-		VectorScale(lightcolor, f, lightcolor);
-	}
-	*/
-
 	shadow = rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows);
+	usestencil = false;
 
 	if (shadow && (gl_stencil || visiblevolumes))
 	{
 		if (!visiblevolumes)
+		{
 			R_Shadow_Stage_ShadowVolumes();
+			usestencil = true;
+		}
 		ent = &cl_entities[0].render;
 		if (r_shadow_staticworldlights.integer && rtlight->compiled)
 		{
@@ -2409,17 +2734,17 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 				GL_LockArrays(0, mesh->numverts);
 				if (r_shadowstage == SHADOWSTAGE_STENCIL)
 				{
-					// decrement stencil if frontface is behind depthbuffer
-					qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
-					qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
-					R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-					c_rtcached_shadowmeshes++;
-					c_rtcached_shadowtris += mesh->numtriangles;
 					// increment stencil if backface is behind depthbuffer
 					qglCullFace(GL_BACK); // quake is backwards, this culls front faces
 					qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
+					R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
+					c_rtcached_shadowmeshes++;
+					c_rtcached_shadowtris += mesh->numtriangles;
+					// decrement stencil if frontface is behind depthbuffer
+					qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
+					qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
 				}
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
+				R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
 				c_rtcached_shadowmeshes++;
 				c_rtcached_shadowtris += mesh->numtriangles;
 				GL_LockArrays(0, 0);
@@ -2428,7 +2753,7 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 		else if (numsurfaces)
 		{
 			Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
-			ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist);
+			ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist, rtlight->cullmins, rtlight->cullmaxs);
 		}
 		if (r_drawentities.integer)
 		{
@@ -2440,7 +2765,7 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 				{
 					if (!BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs))
 						continue;
-					if (cl.worldmodel != NULL && cl.worldmodel->brush.BoxTouchingPVS != NULL && !cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, clusterpvs, ent->mins, ent->maxs))
+					if (r_refdef.worldmodel != NULL && r_refdef.worldmodel->brush.BoxTouchingPVS != NULL && !r_refdef.worldmodel->brush.BoxTouchingPVS(r_refdef.worldmodel, clusterpvs, ent->mins, ent->maxs))
 						continue;
 				}
 				if (!(ent->flags & RENDER_SHADOW) || !ent->model || !ent->model->DrawShadowVolume)
@@ -2449,18 +2774,27 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 				// light emitting entities should not cast their own shadow
 				if (VectorLength2(relativelightorigin) < 0.1)
 					continue;
-				ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, ent->model->nummodelsurfaces, ent->model->surfacelist);
+				relativelightmins[0] = relativelightorigin[0] - rtlight->radius;
+				relativelightmins[1] = relativelightorigin[1] - rtlight->radius;
+				relativelightmins[2] = relativelightorigin[2] - rtlight->radius;
+				relativelightmaxs[0] = relativelightorigin[0] + rtlight->radius;
+				relativelightmaxs[1] = relativelightorigin[1] + rtlight->radius;
+				relativelightmaxs[2] = relativelightorigin[2] + rtlight->radius;
+				ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, ent->model->nummodelsurfaces, ent->model->surfacelist, relativelightmins, relativelightmaxs);
 			}
 		}
 	}
 
 	if (!visiblevolumes)
 	{
-		R_Shadow_Stage_Light(shadow && gl_stencil);
+		R_Shadow_Stage_Light(usestencil);
 
 		ent = &cl_entities[0].render;
 		if (ent->model && ent->model->DrawLight && (ent->flags & RENDER_LIGHT))
 		{
+			lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha;
+			lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha;
+			lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha;
 			Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
 			Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
 			Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix);
@@ -2470,10 +2804,10 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 			{
 				R_Mesh_Matrix(&ent->matrix);
 				for (mesh = rtlight->static_meshchain_light;mesh;mesh = mesh->next)
-					R_Shadow_RenderLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, mesh->map_diffuse, mesh->map_normal, mesh->map_specular, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale);
+					R_Shadow_RenderLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, mesh->map_diffuse, mesh->map_normal, mesh->map_specular, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale);
 			}
 			else
-				ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, numsurfaces, surfacelist);
+				ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, numsurfaces, surfacelist);
 		}
 		if (r_drawentities.integer)
 		{
@@ -2484,7 +2818,9 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
 				// transparent meshes are deferred for later
 				if (ent->visframe == r_framecount && BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs) && ent->model && ent->model->DrawLight && (ent->flags & (RENDER_LIGHT | RENDER_TRANSPARENT)) == RENDER_LIGHT)
 				{
-					VectorScale(lightcolor, ent->alpha, lightcolor2);
+					lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha;
+					lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha;
+					lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha;
 					Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
 					Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
 					Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix);
@@ -2503,7 +2839,7 @@ void R_ShadowVolumeLighting(int visiblevolumes)
 	dlight_t *light;
 	rmeshstate_t m;
 
-	if (cl.worldmodel && strncmp(cl.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
+	if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
 		R_Shadow_EditLights_Reload_f();
 
 	if (visiblevolumes)
@@ -2597,7 +2933,7 @@ rtexture_t *R_Shadow_LoadCubemap(const char *basename)
 		for (i = 0;i < 6;i++)
 		{
 			// generate an image name based on the base and and suffix
-			snprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
+			dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
 			// load it
 			if ((image_rgba = loadimagepixels(name, false, cubemapsize, cubemapsize)))
 			{
@@ -2690,7 +3026,7 @@ void R_Shadow_UpdateWorldLight(dlight_t *light, vec3_t origin, vec3_t angles, ve
 	light->corona = corona;
 	if (!cubemapname)
 		cubemapname = "";
-	strlcpy(light->cubemapname, cubemapname, strlen(light->cubemapname));
+	strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
 	light->coronasizescale = coronasizescale;
 	light->ambientscale = ambientscale;
 	light->diffusescale = diffusescale;
@@ -2792,14 +3128,14 @@ void R_Shadow_SelectLightInView(void)
 void R_Shadow_LoadWorldLights(void)
 {
 	int n, a, style, shadow, flags;
-	char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t;
+	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 (cl.worldmodel == NULL)
+	if (r_refdef.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
+	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
 	strlcat (name, ".rtlights", sizeof (name));
 	lightsstring = FS_LoadFile(name, tempmempool, false);
 	if (lightsstring)
@@ -2825,11 +3161,11 @@ void R_Shadow_LoadWorldLights(void)
 			}
 			*/
 			t = s;
-			while (*s && *s != '\n')
+			while (*s && *s != '\n' && *s != '\r')
 				s++;
 			if (!*s)
 				break;
-			*s = 0;
+			tempchar = *s;
 			shadow = true;
 			// check for modifier flags
 			if (*t == '!')
@@ -2837,7 +3173,9 @@ void R_Shadow_LoadWorldLights(void)
 				shadow = false;
 				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);
+			*s = tempchar;
 			if (a < 18)
 				flags = LIGHTFLAG_REALTIMEMODE;
 			if (a < 17)
@@ -2854,7 +3192,12 @@ void R_Shadow_LoadWorldLights(void)
 				corona = 0;
 			if (a < 9 || !strcmp(cubemapname, "\"\""))
 				cubemapname[0] = 0;
-			*s = '\n';
+			// remove quotes on cubemapname
+			if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
+			{
+				cubemapname[strlen(cubemapname)-1] = 0;
+				strcpy(cubemapname, cubemapname + 1);
+			}
 			if (a < 8)
 			{
 				Con_Printf("found %d parameters on line %i, should be 8 or more parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style \"cubemapname\" corona angles[0] angles[1] angles[2] coronasizescale ambientscale diffusescale specularscale flags)\n", a, n + 1);
@@ -2863,7 +3206,10 @@ void R_Shadow_LoadWorldLights(void)
 			VectorScale(color, r_editlights_rtlightscolorscale.value, color);
 			radius *= r_editlights_rtlightssizescale.value;
 			R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
-			s++;
+			if (*s == '\r')
+				s++;
+			if (*s == '\n')
+				s++;
 			n++;
 		}
 		if (*s)
@@ -2881,12 +3227,12 @@ void R_Shadow_SaveWorldLights(void)
 	char line[1024];
 	if (!r_shadow_worldlightchain)
 		return;
-	if (cl.worldmodel == NULL)
+	if (r_refdef.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
+	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
 	strlcat (name, ".rtlights", sizeof (name));
 	bufchars = bufmaxchars = 0;
 	buf = NULL;
@@ -2925,14 +3271,14 @@ void R_Shadow_SaveWorldLights(void)
 void R_Shadow_LoadLightsFile(void)
 {
 	int n, a, style;
-	char name[MAX_QPATH], *lightsstring, *s, *t;
+	char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
 	float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
-	if (cl.worldmodel == NULL)
+	if (r_refdef.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
-	FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
+	FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
 	strlcat (name, ".lights", sizeof (name));
 	lightsstring = FS_LoadFile(name, tempmempool, false);
 	if (lightsstring)
@@ -2942,13 +3288,14 @@ void R_Shadow_LoadLightsFile(void)
 		while (*s)
 		{
 			t = s;
-			while (*s && *s != '\n')
+			while (*s && *s != '\n' && *s != '\r')
 				s++;
 			if (!*s)
 				break;
+			tempchar = *s;
 			*s = 0;
 			a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &origin[0], &origin[1], &origin[2], &falloff, &color[0], &color[1], &color[2], &subtract, &spotdir[0], &spotdir[1], &spotdir[2], &spotcone, &distbias, &style);
-			*s = '\n';
+			*s = tempchar;
 			if (a < 14)
 			{
 				Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
@@ -2958,7 +3305,10 @@ void R_Shadow_LoadLightsFile(void)
 			radius = bound(15, radius, 4096);
 			VectorScale(color, (2.0f / (8388608.0f)), color);
 			R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
-			s++;
+			if (*s == '\r')
+				s++;
+			if (*s == '\n')
+				s++;
 			n++;
 		}
 		if (*s)
@@ -2978,18 +3328,18 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
 	float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
 	char key[256], value[1024];
 
-	if (cl.worldmodel == NULL)
+	if (r_refdef.worldmodel == NULL)
 	{
 		Con_Print("No map loaded.\n");
 		return;
 	}
 	// try to load a .ent file first
-	FS_StripExtension (cl.worldmodel->name, key, sizeof (key));
+	FS_StripExtension (r_refdef.worldmodel->name, key, sizeof (key));
 	strlcat (key, ".ent", sizeof (key));
 	data = entfiledata = FS_LoadFile(key, tempmempool, true);
 	// and if that is not found, fall back to the bsp file entity string
 	if (!data)
-		data = cl.worldmodel->brush.entities;
+		data = r_refdef.worldmodel->brush.entities;
 	if (!data)
 		return;
 	for (entnum = 0;COM_ParseToken(&data, false) && com_token[0] == '{';entnum++)
@@ -3129,7 +3479,7 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
 			}
 			else if (!strcmp("style", key))
 				style = atoi(value);
-			else if (cl.worldmodel->type == mod_brushq3)
+			else if (r_refdef.worldmodel->type == mod_brushq3)
 			{
 				if (!strcmp("scale", key))
 					lightscale = atof(value);
@@ -3228,9 +3578,9 @@ void R_Shadow_EditLights_Clear_f(void)
 
 void R_Shadow_EditLights_Reload_f(void)
 {
-	if (!cl.worldmodel)
+	if (!r_refdef.worldmodel)
 		return;
-	strlcpy(r_shadow_mapname, cl.worldmodel->name, sizeof(r_shadow_mapname));
+	strlcpy(r_shadow_mapname, r_refdef.worldmodel->name, sizeof(r_shadow_mapname));
 	R_Shadow_ClearWorldLights();
 	R_Shadow_LoadWorldLights();
 	if (r_shadow_worldlightchain == NULL)
@@ -3243,7 +3593,7 @@ void R_Shadow_EditLights_Reload_f(void)
 
 void R_Shadow_EditLights_Save_f(void)
 {
-	if (!cl.worldmodel)
+	if (!r_refdef.worldmodel)
 		return;
 	R_Shadow_SaveWorldLights();
 }
@@ -3612,7 +3962,7 @@ void R_Shadow_EditLights_DrawSelectedLightProperties(void)
 	sprintf(temp, "Specular     : %f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);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);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);y += 8;
-}                 
+}
 
 void R_Shadow_EditLights_ToggleShadow_f(void)
 {