X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rsurf.c;h=f84e671d635fa32c3728834d9b967798c14fcf05;hb=0dab13d8227daa31cf55e80977cef0397e7357c6;hp=3fd699d2653f3d8a6935d79e44aff6ef5ac19d88;hpb=22ab5b495c2c169dc7755003294e5431ad300265;p=xonotic%2Fdarkplaces.git

diff --git a/gl_rsurf.c b/gl_rsurf.c
index 3fd699d2..f84e671d 100644
--- a/gl_rsurf.c
+++ b/gl_rsurf.c
@@ -763,14 +763,15 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
 	GL_DepthTest(true);
 
 	memset(&m, 0, sizeof(m));
-	R_Mesh_State_Texture(&m);
-
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 	GL_ColorMask(1,1,1,1);
@@ -784,27 +785,11 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 	float alpha;
 	float modelorg[3];
 	texture_t *texture;
-	matrix4x4_t tempmatrix;
-	float	args[4] = {0.05f,0,0,0.04f};
-
-	if (gl_textureshader && r_watershader.value && !fogenabled)
-	{
-		Matrix4x4_CreateTranslate(&tempmatrix, sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
-		R_Mesh_TextureMatrix(1, &tempmatrix);
-		Matrix4x4_CreateFromQuakeEntity(&tempmatrix, 0, 0, 0, 0, 0, 0, r_watershader.value);
-		R_Mesh_TextureMatrix(0, &tempmatrix);
-	}
-	else if (r_waterscroll.value)
-	{
-		// scrolling in texture matrix
-		Matrix4x4_CreateTranslate(&tempmatrix, sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
-		R_Mesh_TextureMatrix(0, &tempmatrix);
-	}
+	float args[4] = {0.05f,0,0,0.04f};
 
 	R_Mesh_Matrix(&ent->matrix);
 	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
 
-	memset(&m, 0, sizeof(m));
 	texture = surf->texinfo->texture->currentframe;
 	alpha = texture->currentalpha;
 	if (texture->rendertype == SURFRENDER_ADD)
@@ -822,68 +807,70 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		GL_DepthMask(true);
 	}
+	GL_DepthTest(true);
+	GL_Color(1, 1, 1, alpha);
+	memset(&m, 0, sizeof(m));
+	m.pointer_vertex = surf->mesh.data_vertex3f;
 	if (gl_textureshader && r_watershader.value && !fogenabled)
 	{
 		m.tex[0] = R_GetTexture(mod_shared_distorttexture[(int)(cl.time * 16)&63]);
 		m.tex[1] = R_GetTexture(texture->skin.base);
-	}
-	else
-		m.tex[0] = R_GetTexture(texture->skin.base);
-	GL_DepthTest(true);
-	if (fogenabled)
-		GL_ColorPointer(varray_color4f);
-	else
-		GL_Color(1, 1, 1, alpha);
-	if (gl_textureshader && r_watershader.value && !fogenabled)
-	{
-		GL_ActiveTexture (0);
-		qglTexEnvi (GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
-		GL_ActiveTexture (1);
-		qglTexEnvi (GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
-		qglTexEnvi (GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
-		qglTexEnvi (GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
-		qglTexEnvfv (GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
-		qglEnable (GL_TEXTURE_SHADER_NV);
-	}
-
-	GL_VertexPointer(surf->mesh.data_vertex3f);
-	m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-	m.pointer_texcoord[1] = surf->mesh.data_texcoordtexture2f;
-	m.texcombinergb[1] = GL_REPLACE;
-	R_Mesh_State_Texture(&m);
-	if (fogenabled)
-	{
-		R_FillColors(varray_color4f, surf->mesh.num_vertices, 1, 1, 1, alpha);
-		RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, surf->mesh.num_vertices, modelorg);
-	}
-	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+		m.texcombinergb[0] = GL_REPLACE;
+		m.texcombinergb[1] = GL_REPLACE;
+		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+		m.pointer_texcoord[1] = surf->mesh.data_texcoordtexture2f;
+		Matrix4x4_CreateFromQuakeEntity(&m.texmatrix[0], 0, 0, 0, 0, 0, 0, r_watershader.value);
+		Matrix4x4_CreateTranslate(&m.texmatrix[1], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
+		R_Mesh_State(&m);
+
+		GL_ActiveTexture(0);
+		qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
+		GL_ActiveTexture(1);
+		qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
+		qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
+		qglTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
+		qglEnable(GL_TEXTURE_SHADER_NV);
+
+		GL_LockArrays(0, surf->mesh.num_vertices);
+		R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+		GL_LockArrays(0, 0);
 
-	if (gl_textureshader && r_watershader.value && !fogenabled)
-	{
-		qglDisable (GL_TEXTURE_SHADER_NV);
-		GL_ActiveTexture (0);
+		qglDisable(GL_TEXTURE_SHADER_NV);
+		qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
+		GL_ActiveTexture(0);
 	}
-
-	if (fogenabled)
+	else
 	{
-		memset(&m, 0, sizeof(m));
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		GL_DepthMask(false);
-		GL_DepthTest(true);
-		m.tex[0] = R_GetTexture(texture->skin.fog);
-		GL_VertexPointer(surf->mesh.data_vertex3f);
+		if (fogenabled)
+		{
+			R_FillColors(varray_color4f, surf->mesh.num_vertices, 1, 1, 1, alpha);
+			RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, surf->mesh.num_vertices, modelorg);
+			m.pointer_color = varray_color4f;
+		}
+		m.tex[0] = R_GetTexture(texture->skin.base);
 		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-		GL_ColorPointer(varray_color4f);
-		R_Mesh_State_Texture(&m);
-		RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], alpha, 1, surf->mesh.num_vertices, modelorg);
+		if (r_waterscroll.value)
+		{
+			// scrolling in texture matrix
+			Matrix4x4_CreateTranslate(&m.texmatrix[0], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
+		}
+		R_Mesh_State(&m);
+
+		GL_LockArrays(0, surf->mesh.num_vertices);
 		R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
-	}
+		GL_LockArrays(0, 0);
 
-	if ((gl_textureshader && r_watershader.value && !fogenabled) || r_waterscroll.value)
-	{
-		Matrix4x4_CreateIdentity(&tempmatrix);
-		R_Mesh_TextureMatrix(0, &tempmatrix);
-		R_Mesh_TextureMatrix(1, &tempmatrix);
+		if (fogenabled && texture->rendertype != SURFRENDER_ADD)
+		{
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+			GL_DepthMask(false);
+			RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], alpha, 1, surf->mesh.num_vertices, modelorg);
+			m.tex[0] = R_GetTexture(texture->skin.fog);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
+		}
 	}
 }
 
@@ -940,11 +927,11 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m
 	}
 	base = ent->effects & EF_FULLBRIGHT ? 2.0f : r_ambient.value * (1.0f / 64.0f);
 	GL_DepthTest(true);
-	GL_ColorPointer(varray_color4f);
 
-	GL_VertexPointer(surf->mesh.data_vertex3f);
+	m.pointer_color = varray_color4f;
+	m.pointer_vertex = surf->mesh.data_vertex3f;
 	m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-	R_Mesh_State_Texture(&m);
+	R_Mesh_State(&m);
 	R_FillColors(varray_color4f, surf->mesh.num_vertices, base, base, base, currentalpha);
 	if (!(ent->effects & EF_FULLBRIGHT))
 	{
@@ -954,7 +941,9 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m
 			RSurf_AddLightmapToVertexColors_Color4f(surf->mesh.data_lightmapoffsets, varray_color4f,surf->mesh.num_vertices, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles);
 	}
 	RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, colorscale, surf->mesh.num_vertices, modelorg);
+	GL_LockArrays(0, surf->mesh.num_vertices);
 	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
@@ -966,15 +955,17 @@ static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurfac
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
 	GL_DepthMask(false);
 	GL_DepthTest(true);
+	m.pointer_color = varray_color4f;
 	m.tex[0] = R_GetTexture(texture->skin.glow);
-	GL_ColorPointer(varray_color4f);
 
-	GL_VertexPointer(surf->mesh.data_vertex3f);
+	m.pointer_vertex = surf->mesh.data_vertex3f;
 	if (m.tex[0])
 		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-	R_Mesh_State_Texture(&m);
+	R_Mesh_State(&m);
 	RSurf_FoggedColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, 1, 1, currentalpha, 1, surf->mesh.num_vertices, modelorg);
+	GL_LockArrays(0, surf->mesh.num_vertices);
 	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
@@ -986,15 +977,17 @@ static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
 	GL_DepthMask(false);
 	GL_DepthTest(true);
+	m.pointer_color = varray_color4f;
 	m.tex[0] = R_GetTexture(texture->skin.fog);
-	GL_ColorPointer(varray_color4f);
 
-	GL_VertexPointer(surf->mesh.data_vertex3f);
+	m.pointer_vertex = surf->mesh.data_vertex3f;
 	if (m.tex[0])
 		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-	R_Mesh_State_Texture(&m);
+	R_Mesh_State(&m);
 	RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, 1, surf->mesh.num_vertices, modelorg);
+	GL_LockArrays(0, surf->mesh.num_vertices);
 	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
@@ -1026,18 +1019,16 @@ static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(co
 		if (surf->visframe == r_framecount)
 		{
 			lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
-			//if (m.tex[1] != lightmaptexturenum)
-			//{
-				m.tex[1] = lightmaptexturenum;
-			//	R_Mesh_State_Texture(&m);
-			//}
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.tex[1] = lightmaptexturenum;
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
 			m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
 			m.pointer_texcoord[2] = surf->mesh.data_texcoorddetail2f;
 			m.pointer_texcoord[3] = surf->mesh.data_texcoordtexture2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1066,17 +1057,15 @@ static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetail(const
 		if (surf->visframe == r_framecount)
 		{
 			lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
-			//if (m.tex[1] != lightmaptexturenum)
-			//{
-				m.tex[1] = lightmaptexturenum;
-			//	R_Mesh_State_Texture(&m);
-			//}
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.tex[1] = lightmaptexturenum;
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
 			m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
 			m.pointer_texcoord[2] = surf->mesh.data_texcoorddetail2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1102,16 +1091,14 @@ static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmap(const entity
 		if (surf->visframe == r_framecount)
 		{
 			lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
-			//if (m.tex[1] != lightmaptexturenum)
-			//{
-				m.tex[1] = lightmaptexturenum;
-			//	R_Mesh_State_Texture(&m);
-			//}
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.tex[1] = lightmaptexturenum;
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
 			m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1133,10 +1120,12 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent,
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1157,15 +1146,13 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 		if (surf->visframe == r_framecount)
 		{
 			lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
-			//if (m.tex[0] != lightmaptexturenum)
-			//{
-				m.tex[0] = lightmaptexturenum;
-			//	R_Mesh_State_Texture(&m);
-			//}
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.tex[0] = lightmaptexturenum;
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1180,17 +1167,19 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	GL_DepthMask(false);
 	GL_DepthTest(true);
-	GL_ColorPointer(varray_color4f);
+	m.pointer_color = varray_color4f;
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			if (m.tex[0])
 				m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
 			RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, 1, surf->mesh.num_vertices, modelorg);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1209,10 +1198,12 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoorddetail2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1231,10 +1222,12 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1256,10 +1249,12 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, c
 	{
 		if (surf->visframe == r_framecount)
 		{
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1284,15 +1279,13 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(const entity_render_t *
 		if (surf->visframe == r_framecount)
 		{
 			lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
-			//if (m.tex[0] != lightmaptexturenum)
-			//{
-				m.tex[0] = lightmaptexturenum;
-			//	R_Mesh_State_Texture(&m);
-			//}
-			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.tex[0] = lightmaptexturenum;
+			m.pointer_vertex = surf->mesh.data_vertex3f;
 			m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
-			R_Mesh_State_Texture(&m);
+			R_Mesh_State(&m);
+			GL_LockArrays(0, surf->mesh.num_vertices);
 			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+			GL_LockArrays(0, 0);
 		}
 	}
 }
@@ -1541,10 +1534,10 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
 	GL_DepthMask(false);
 	GL_DepthTest(true);
 	R_Mesh_Matrix(&ent->matrix);
-	GL_VertexPointer(varray_vertex3f);
 
 	memset(&m, 0, sizeof(m));
-	R_Mesh_State_Texture(&m);
+	m.pointer_vertex = varray_vertex3f;
+	R_Mesh_State(&m);
 
 	i = portal - ent->model->brushq1.portals;
 	GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f),
@@ -1559,7 +1552,9 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
 	else
 		for (i = 0, v = varray_vertex3f;i < portal->numpoints;i++, v += 3)
 			VectorCopy(portal->points[i].position, v);
+	GL_LockArrays(0, portal->numpoints);
 	R_Mesh_Draw(portal->numpoints, portal->numpoints - 2, polygonelements);
+	GL_LockArrays(0, 0);
 }
 
 // LordHavoc: this is just a nice debugging tool, very slow
@@ -1838,105 +1833,72 @@ void R_Model_Brush_Draw(entity_render_t *ent)
 	R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->brushq1.pvstexturechains);
 }
 
-void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
+void R_Model_Brush_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer)
 {
-#if 0
-	int i;
-	msurface_t *surf;
-	float projectdistance, f, temp[3], lightradius2;
-	if (ent->model == NULL)
-		return;
-	R_Mesh_Matrix(&ent->matrix);
-	lightradius2 = lightradius * lightradius;
-	R_UpdateTextureInfo(ent);
-	projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
-	//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
-	for (i = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;i < ent->model->brushq1.nummodelsurfaces;i++, surf++)
-	{
-		if (surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && surf->flags & SURF_SHADOWCAST)
-		{
-			f = PlaneDiff(relativelightorigin, surf->plane);
-			if (surf->flags & SURF_PLANEBACK)
-				f = -f;
-			// draw shadows only for frontfaces and only if they are close
-			if (f >= 0.1 && f < lightradius)
-			{
-				temp[0] = bound(surf->poly_mins[0], relativelightorigin[0], surf->poly_maxs[0]) - relativelightorigin[0];
-				temp[1] = bound(surf->poly_mins[1], relativelightorigin[1], surf->poly_maxs[1]) - relativelightorigin[1];
-				temp[2] = bound(surf->poly_mins[2], relativelightorigin[2], surf->poly_maxs[2]) - relativelightorigin[2];
-				if (DotProduct(temp, temp) < lightradius2)
-					R_Shadow_VolumeFromSphere(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_vertex3f, surf->mesh.data_element3i, surf->mesh.data_neighbor3i, relativelightorigin, projectdistance, lightradius);
-			}
-		}
-	}
-#else
-	int t, leafnum, marksurfnum, trianglenum;
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs;
+	int t, leafindex, marksurfaceindex, surfaceindex, triangleindex, outnumclusters = 0, outnumsurfaces = 0;
 	const int *e;
-	msurface_t *surf;
+	const float *v[3];
+	msurface_t *surface;
 	mleaf_t *leaf;
 	const qbyte *pvs;
-	float projectdistance;
-	const float *v[3];
-	vec3_t lightmins, lightmaxs;
-	if (ent->model == NULL)
-		return;
-	R_Mesh_Matrix(&ent->matrix);
-	R_UpdateTextureInfo(ent);
-	projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
 	lightmins[0] = relativelightorigin[0] - lightradius;
 	lightmins[1] = relativelightorigin[1] - lightradius;
 	lightmins[2] = relativelightorigin[2] - lightradius;
 	lightmaxs[0] = relativelightorigin[0] + lightradius;
 	lightmaxs[1] = relativelightorigin[1] + lightradius;
 	lightmaxs[2] = relativelightorigin[2] + lightradius;
-	/*
-	R_Shadow_PrepareShadowMark(ent->model->brush.shadowmesh->numtriangles);
-	maxmarksurfaces = sizeof(surfacelist) / sizeof(surfacelist[0]);
-	ent->model->brushq1.GetVisible(ent->model, relativelightorigin, lightmins, lightmaxs, 0, NULL, NULL, maxmarkleafs, markleaf, &nummarkleafs);
-	for (marksurfacenum = 0;marksurfacenum < nummarksurfaces;marksurfacenum++)
+	*outnumclusterspointer = 0;
+	*outnumsurfacespointer = 0;
+	memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
+	memset(outsurfacepvs, 0, (model->numsurfaces + 7) >> 3);
+	if (model == NULL)
 	{
-		surf = marksurface[marksurfacenum];
-		if (surf->shadowmark != shadowmarkcount)
-		{
-			surf->shadowmark = shadowmarkcount;
-			if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+		VectorCopy(lightmins, outmins);
+		VectorCopy(lightmaxs, outmaxs);
+		return;
+	}
+	VectorCopy(relativelightorigin, outmins);
+	VectorCopy(relativelightorigin, outmaxs);
+	if (model->brush.GetPVS)
+		pvs = model->brush.GetPVS(model, relativelightorigin);
+	else
+		pvs = NULL;
+	// FIXME: use BSP recursion as lights are often small
+	for (leafindex = 0, leaf = model->brushq1.data_leafs;leafindex < model->brushq1.num_leafs;leafindex++, leaf++)
+	{
+		if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && (pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
+		{
+			outmins[0] = min(outmins[0], leaf->mins[0]);
+			outmins[1] = min(outmins[1], leaf->mins[1]);
+			outmins[2] = min(outmins[2], leaf->mins[2]);
+			outmaxs[0] = max(outmaxs[0], leaf->maxs[0]);
+			outmaxs[1] = max(outmaxs[1], leaf->maxs[1]);
+			outmaxs[2] = max(outmaxs[2], leaf->maxs[2]);
+			if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
 			{
-				for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
-				{
-					v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
-					v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
-					v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
-					if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
-						shadowmarklist[numshadowmark++] = t;
-				}
+				SETPVSBIT(outclusterpvs, leaf->clusterindex);
+				outclusterlist[outnumclusters++] = leaf->clusterindex;
 			}
-		}
-	}
-	*/
-	R_Shadow_PrepareShadowMark(ent->model->brush.shadowmesh->numtriangles);
-	if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
-	{
-		pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
-		// FIXME: use BSP recursion in q1bsp as dlights are often small
-		for (leafnum = 0, leaf = ent->model->brushq1.data_leafs;leafnum < ent->model->brushq1.num_leafs;leafnum++, leaf++)
-		{
-			if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+			for (marksurfaceindex = 0;marksurfaceindex < leaf->nummarksurfaces;marksurfaceindex++)
 			{
-				for (marksurfnum = 0;marksurfnum < leaf->nummarksurfaces;marksurfnum++)
+				surfaceindex = leaf->firstmarksurface[marksurfaceindex];
+				if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
 				{
-					surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[marksurfnum];
-					if (surf->shadowmark != shadowmarkcount)
+					surface = model->brushq1.surfaces + surfaceindex;
+					if (BoxesOverlap(lightmins, lightmaxs, surface->poly_mins, surface->poly_maxs))
 					{
-						surf->shadowmark = shadowmarkcount;
-						if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+						for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->mesh.num_triangles;triangleindex++, t++, e += 3)
 						{
-							for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
+							v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+							v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+							v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+							if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
 							{
-								v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
-								v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
-								v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
-								if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
-									shadowmarklist[numshadowmark++] = t;
+								SETPVSBIT(outsurfacepvs, surfaceindex);
+								outsurfacelist[outnumsurfaces++] = surfaceindex;
+								break;
 							}
 						}
 					}
@@ -1944,85 +1906,85 @@ void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelighto
 			}
 		}
 	}
-	else
+
+	// limit combined leaf box to light boundaries
+	outmins[0] = max(outmins[0], lightmins[0]);
+	outmins[1] = max(outmins[1], lightmins[1]);
+	outmins[2] = max(outmins[2], lightmins[2]);
+	outmaxs[0] = min(outmaxs[0], lightmaxs[0]);
+	outmaxs[1] = min(outmaxs[1], lightmaxs[1]);
+	outmaxs[2] = min(outmaxs[2], lightmaxs[2]);
+
+	*outnumclusterspointer = outnumclusters;
+	*outnumsurfacespointer = outnumsurfaces;
+}
+
+void R_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
+{
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs;
+	msurface_t *surface;
+	int surfacelistindex, j, t;
+	const int *e;
+	const float *v[3];
+	if (r_drawcollisionbrushes.integer < 2)
 	{
-		for (marksurfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;marksurfnum < ent->model->brushq1.nummodelsurfaces;marksurfnum++, surf++)
+		lightmins[0] = relativelightorigin[0] - lightradius;
+		lightmins[1] = relativelightorigin[1] - lightradius;
+		lightmins[2] = relativelightorigin[2] - lightradius;
+		lightmaxs[0] = relativelightorigin[0] + lightradius;
+		lightmaxs[1] = relativelightorigin[1] + lightradius;
+		lightmaxs[2] = relativelightorigin[2] + lightradius;
+		R_Mesh_Matrix(&ent->matrix);
+		R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
+		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
-			if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+			surface = model->brushq1.surfaces + surfacelist[surfacelistindex];
+			for (j = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < surface->mesh.num_triangles;j++, t++, e += 3)
 			{
-				for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
-				{
-					v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
-					v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
-					v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
-					if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
-						shadowmarklist[numshadowmark++] = t;
-				}
+				v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+				v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+				v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+				if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+					shadowmarklist[numshadowmark++] = t;
 			}
 		}
+		R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius, numshadowmark, shadowmarklist);
 	}
-	R_Shadow_VolumeFromList(ent->model->brush.shadowmesh->numverts, ent->model->brush.shadowmesh->numtriangles, ent->model->brush.shadowmesh->vertex3f, ent->model->brush.shadowmesh->element3i, ent->model->brush.shadowmesh->neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
-#endif
 }
 
-void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
+void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist)
 {
-	int leafnum, marksurfnum;
-	msurface_t *surf;
-	mleaf_t *leaf;
-	const qbyte *pvs;
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs, modelorg;
+	msurface_t *surface;
 	texture_t *t;
-	float lightmins[3], lightmaxs[3];
-	if (ent->model == NULL)
-		return;
-	R_Mesh_Matrix(&ent->matrix);
-	lightmins[0] = relativelightorigin[0] - lightradius;
-	lightmins[1] = relativelightorigin[1] - lightradius;
-	lightmins[2] = relativelightorigin[2] - lightradius;
-	lightmaxs[0] = relativelightorigin[0] + lightradius;
-	lightmaxs[1] = relativelightorigin[1] + lightradius;
-	lightmaxs[2] = relativelightorigin[2] + lightradius;
-	R_UpdateTextureInfo(ent);
-	shadowmarkcount++;
-	if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
+	int surfacelistindex;
+	if (r_drawcollisionbrushes.integer < 2)
 	{
-		pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
-		for (leafnum = 0, leaf = ent->model->brushq1.data_leafs;leafnum < ent->model->brushq1.num_leafs;leafnum++, leaf++)
+		lightmins[0] = relativelightorigin[0] - lightradius;
+		lightmins[1] = relativelightorigin[1] - lightradius;
+		lightmins[2] = relativelightorigin[2] - lightradius;
+		lightmaxs[0] = relativelightorigin[0] + lightradius;
+		lightmaxs[1] = relativelightorigin[1] + lightradius;
+		lightmaxs[2] = relativelightorigin[2] + lightradius;
+		R_Mesh_Matrix(&ent->matrix);
+		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
+		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
-			if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+			surface = model->brushq1.surfaces + surfacelist[surfacelistindex];
+			if (r_shadow_compilingrtlight)
 			{
-				for (marksurfnum = 0;marksurfnum < leaf->nummarksurfaces;marksurfnum++)
-				{
-					surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[marksurfnum];
-					if (surf->shadowmark != shadowmarkcount)
-					{
-						surf->shadowmark = shadowmarkcount;
-						if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && (ent != &cl_entities[0].render || surf->visframe == r_framecount))
-						{
-							t = surf->texinfo->texture->currentframe;
-							if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
-							{
-								R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, lightcubemap);
-								R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, lightcubemap);
-							}
-						}
-					}
-				}
+				// if compiling an rtlight, capture the mesh
+				t = surface->texinfo->texture;
+				if (t->shader == &Cshader_wall_lightmap && t->skin.fog == NULL && (t->flags & SURF_SHADOWLIGHT))
+					Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_light, surface->texinfo->texture->skin.base, surface->texinfo->texture->skin.gloss, surface->texinfo->texture->skin.nmap, surface->mesh.data_vertex3f, surface->mesh.data_svector3f, surface->mesh.data_tvector3f, surface->mesh.data_normal3f, surface->mesh.data_texcoordtexture2f, surface->mesh.num_triangles, surface->mesh.data_element3i);
 			}
-		}
-	}
-	else
-	{
-		for (marksurfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;marksurfnum < ent->model->brushq1.nummodelsurfaces;marksurfnum++, surf++)
-		{
-			if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && (ent != &cl_entities[0].render || surf->visframe == r_framecount))
+			else if (ent != &cl_entities[0].render || surface->visframe == r_framecount)
 			{
-				t = surf->texinfo->texture->currentframe;
-				if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
-				{
-					R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, lightcubemap);
-					R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, lightcubemap);
-				}
+				t = surface->texinfo->texture->currentframe;
+				if (t->rendertype == SURFRENDER_OPAQUE && (t->flags & SURF_SHADOWLIGHT))
+						R_Shadow_RenderLighting(surface->mesh.num_vertices, surface->mesh.num_triangles, surface->mesh.data_element3i, surface->mesh.data_vertex3f, surface->mesh.data_svector3f, surface->mesh.data_tvector3f, surface->mesh.data_normal3f, surface->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, t->skin.gloss, lightcubemap, LIGHTING_DIFFUSE | LIGHTING_SPECULAR);
 			}
 		}
 	}
@@ -2031,21 +1993,31 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 void R_DrawCollisionBrush(colbrushf_t *brush)
 {
 	int i;
+	rmeshstate_t m;
+	memset(&m, 0, sizeof(m));
+	m.pointer_vertex = brush->points->v;
+	R_Mesh_State(&m);
 	i = ((int)brush) / sizeof(colbrushf_t);
 	GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
-	GL_VertexPointer(brush->points->v);
+	GL_LockArrays(0, brush->numpoints);
 	R_Mesh_Draw(brush->numpoints, brush->numtriangles, brush->elements);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawCollisionFace(entity_render_t *ent, q3mface_t *face)
 {
 	int i;
+	rmeshstate_t m;
 	if (!face->num_collisiontriangles)
 		return;
+	memset(&m, 0, sizeof(m));
+	m.pointer_vertex = face->data_collisionvertex3f;
+	R_Mesh_State(&m);
 	i = ((int)face) / sizeof(q3mface_t);
 	GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
-	GL_VertexPointer(face->data_collisionvertex3f);
+	GL_LockArrays(0, face->num_collisionvertices);
 	R_Mesh_Draw(face->num_collisionvertices, face->num_collisiontriangles, face->data_collisionelement3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3mface_t *face)
@@ -2081,10 +2053,12 @@ void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3mface_t *face)
 	GL_DepthTest(true);
 
 	memset(&m, 0, sizeof(m));
-	R_Mesh_State_Texture(&m);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
 
-	GL_VertexPointer(face->data_vertex3f);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 	GL_ColorMask(1,1,1,1);
 }
 
@@ -2103,9 +2077,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(entity_render_t *ent, q3mface_t
 	}
 	else
 		GL_Color(0, 0, 0, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *ent, q3mface_t *face)
@@ -2121,9 +2097,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *en
 	m.pointer_texcoord[1] = face->data_texcoordlightmap2f;
 	m.texrgbscale[1] = 2;
 	GL_Color(1, 1, 1, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3mface_t *face)
@@ -2136,9 +2114,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3mface_t *f
 	m.tex[0] = R_GetTexture(face->texture->skin.base);
 	m.pointer_texcoord[0] = face->data_texcoordtexture2f;
 	GL_Color(1, 1, 1, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3mface_t *face)
@@ -2151,9 +2131,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3mface_t *
 	m.tex[0] = R_GetTexture(face->lightmaptexture);
 	m.pointer_texcoord[0] = face->data_texcoordlightmap2f;
 	GL_Color(1, 1, 1, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3mface_t *face)
@@ -2169,9 +2151,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3mface
 		GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
 	else
 		GL_Color(1, 1, 1, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3mface_t *face)
@@ -2189,9 +2173,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3mface_t *face
 	}
 	else
 		GL_Color(0, 0, 0, 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3mface_t *face)
@@ -2211,10 +2197,10 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3mfac
 	if (mul == 2 && gl_combine.integer)
 	{
 		m.texrgbscale[0] = 2;
-		GL_ColorPointer(face->data_color4f);
+		m.pointer_color = face->data_color4f;
 	}
 	else if (mul == 1)
-		GL_ColorPointer(face->data_color4f);
+		m.pointer_color = face->data_color4f;
 	else
 	{
 		for (i = 0;i < face->num_vertices;i++)
@@ -2224,11 +2210,13 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3mfac
 			varray_color4f[i*4+2] = face->data_color4f[i*4+2] * mul;
 			varray_color4f[i*4+3] = face->data_color4f[i*4+3];
 		}
-		GL_ColorPointer(varray_color4f);
+		m.pointer_color = varray_color4f;
 	}
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3mface_t *face)
@@ -2240,12 +2228,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3mface_t
 	GL_BlendFunc(GL_ONE, GL_ZERO);
 	GL_DepthMask(true);
 	GL_DepthTest(true);
-	R_Mesh_State_Texture(&m);
 	mul = 2.0f;
 	if (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value != 1)
 		mul *= r_shadow_realtime_world_lightmaps.value;
 	if (mul == 1)
-		GL_ColorPointer(face->data_color4f);
+		m.pointer_color = face->data_color4f;
 	else
 	{
 		for (i = 0;i < face->num_vertices;i++)
@@ -2255,10 +2242,13 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3mface_t
 			varray_color4f[i*4+2] = face->data_color4f[i*4+2] * 2.0f;
 			varray_color4f[i*4+3] = face->data_color4f[i*4+3];
 		}
-		GL_ColorPointer(varray_color4f);
+		m.pointer_color = varray_color4f;
 	}
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3mface_t *face)
@@ -2271,9 +2261,11 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3
 	m.tex[0] = R_GetTexture(face->texture->skin.base);
 	m.pointer_texcoord[0] = face->data_texcoordtexture2f;
 	GL_Color(r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), 1);
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 }
 
 void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
@@ -2304,7 +2296,7 @@ void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
 		else
 		{
 			if (ent->alpha == 1)
-				GL_ColorPointer(face->data_color4f);
+				m.pointer_color = face->data_color4f;
 			else
 			{
 				int i;
@@ -2315,7 +2307,7 @@ void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
 					varray_color4f[i*4+2] = face->data_color4f[i*4+2];
 					varray_color4f[i*4+3] = face->data_color4f[i*4+3] * ent->alpha;
 				}
-				GL_ColorPointer(varray_color4f);
+				m.pointer_color = varray_color4f;
 			}
 		}
 	}
@@ -2329,12 +2321,14 @@ void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
 			varray_color4f[i*4+2] = face->data_color4f[i*4+2] * 2.0f;
 			varray_color4f[i*4+3] = face->data_color4f[i*4+3] * ent->alpha;
 		}
-		GL_ColorPointer(varray_color4f);
+		m.pointer_color = varray_color4f;
 	}
-	R_Mesh_State_Texture(&m);
-	GL_VertexPointer(face->data_vertex3f);
+	m.pointer_vertex = face->data_vertex3f;
+	R_Mesh_State(&m);
 	qglDisable(GL_CULL_FACE);
+	GL_LockArrays(0, face->num_vertices);
 	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+	GL_LockArrays(0, 0);
 	qglEnable(GL_CULL_FACE);
 }
 
@@ -2348,7 +2342,6 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 			return;
 	}
 	c_faces++;
-	face->visframe = r_framecount;
 	if ((face->texture->surfaceparms & Q3SURFACEPARM_TRANS) || ent->alpha < 1 || (ent->effects & EF_ADDITIVE))
 	{
 		vec3_t facecenter, center;
@@ -2400,7 +2393,7 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 		R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(ent, face);
 }
 
-void R_Q3BSP_RecursiveWorldNode(entity_render_t *ent, q3mnode_t *node, const vec3_t modelorg, qbyte *pvs, int markframe)
+void R_Q3BSP_RecursiveWorldNode(q3mnode_t *node)
 {
 	int i;
 	q3mleaf_t *leaf;
@@ -2411,15 +2404,15 @@ void R_Q3BSP_RecursiveWorldNode(entity_render_t *ent, q3mnode_t *node, const vec
 		if (!node->plane)
 			break;
 		c_nodes++;
-		R_Q3BSP_RecursiveWorldNode(ent, node->children[0], modelorg, pvs, markframe);
+		R_Q3BSP_RecursiveWorldNode(node->children[0]);
 		node = node->children[1];
 	}
 	leaf = (q3mleaf_t *)node;
-	if (CHECKPVSBIT(pvs, leaf->clusterindex))
+	if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
 	{
 		c_leafs++;
 		for (i = 0;i < leaf->numleaffaces;i++)
-			leaf->firstleafface[i]->markframe = markframe;
+			leaf->firstleafface[i]->visframe = r_framecount;
 	}
 }
 
@@ -2427,17 +2420,17 @@ void R_Q3BSP_RecursiveWorldNode(entity_render_t *ent, q3mnode_t *node, const vec
 // node-referenced leafs, as some maps are incorrectly compiled with leafs for
 // the submodels (which would render the submodels occasionally, as part of
 // the world - not good)
-void R_Q3BSP_MarkLeafPVS(entity_render_t *ent, qbyte *pvs, int markframe)
+void R_Q3BSP_MarkLeafPVS(void)
 {
 	int i, j;
 	q3mleaf_t *leaf;
-	for (j = 0, leaf = ent->model->brushq3.data_leafs;j < ent->model->brushq3.num_leafs;j++, leaf++)
+	for (j = 0, leaf = cl.worldmodel->brushq3.data_leafs;j < cl.worldmodel->brushq3.num_leafs;j++, leaf++)
 	{
-		if (CHECKPVSBIT(pvs, leaf->clusterindex))
+		if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
 		{
 			c_leafs++;
 			for (i = 0;i < leaf->numleaffaces;i++)
-				leaf->firstleafface[i]->markframe = markframe;
+				leaf->firstleafface[i]->visframe = r_framecount;
 		}
 	}
 }
@@ -2450,22 +2443,21 @@ void R_Q3BSP_DrawSky(entity_render_t *ent)
 	q3mface_t *face;
 	vec3_t modelorg;
 	model_t *model;
-	qbyte *pvs;
 	R_Mesh_Matrix(&ent->matrix);
 	model = ent->model;
 	if (r_drawcollisionbrushes.integer < 2)
 	{
 		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-		if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
+		if (ent == &cl_entities[0].render)
 		{
 			if (r_q3bsp_framecount != r_framecount)
 			{
 				r_q3bsp_framecount = r_framecount;
-				R_Q3BSP_RecursiveWorldNode(ent, model->brushq3.data_nodes, modelorg, pvs, r_framecount);
-				//R_Q3BSP_MarkLeafPVS(ent, pvs, r_framecount);
+				R_Q3BSP_RecursiveWorldNode(model->brushq3.data_nodes);
+				//R_Q3BSP_MarkLeafPVS();
 			}
 			for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
-				if (face->markframe == r_framecount && (face->texture->surfaceflags & Q3SURFACEFLAG_SKY) && !R_CullBox(face->mins, face->maxs))
+				if (face->visframe == r_framecount && (face->texture->surfaceflags & Q3SURFACEFLAG_SKY) && !R_CullBox(face->mins, face->maxs))
 					R_Q3BSP_DrawSkyFace(ent, face);
 		}
 		else
@@ -2487,16 +2479,17 @@ void R_Q3BSP_Draw(entity_render_t *ent)
 	if (r_drawcollisionbrushes.integer < 2)
 	{
 		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-		if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
+		if (ent == &cl_entities[0].render)
 		{
+			if (model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
 			if (r_q3bsp_framecount != r_framecount)
 			{
 				r_q3bsp_framecount = r_framecount;
-				R_Q3BSP_RecursiveWorldNode(ent, model->brushq3.data_nodes, modelorg, pvs, r_framecount);
-				//R_Q3BSP_MarkLeafPVS(ent, pvs, r_framecount);
+				R_Q3BSP_RecursiveWorldNode(model->brushq3.data_nodes);
+				//R_Q3BSP_MarkLeafPVS();
 			}
 			for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
-				if (face->markframe == r_framecount && !R_CullBox(face->mins, face->maxs))
+				if (face->visframe == r_framecount && !R_CullBox(face->mins, face->maxs))
 					R_Q3BSP_DrawFace(ent, face);
 		}
 		else
@@ -2505,12 +2498,9 @@ void R_Q3BSP_Draw(entity_render_t *ent)
 	}
 	if (r_drawcollisionbrushes.integer >= 1)
 	{
-		rmeshstate_t m;
-		memset(&m, 0, sizeof(m));
 		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
 		GL_DepthMask(false);
 		GL_DepthTest(true);
-		R_Mesh_State_Texture(&m);
 		qglPolygonOffset(r_drawcollisionbrushes_polygonfactor.value, r_drawcollisionbrushes_polygonoffset.value);
 		for (i = 0;i < model->brushq3.data_thismodel->numbrushes;i++)
 			if (model->brushq3.data_thismodel->firstbrush[i].colbrushf && model->brushq3.data_thismodel->firstbrush[i].colbrushf->numtriangles)
@@ -2522,161 +2512,156 @@ void R_Q3BSP_Draw(entity_render_t *ent)
 	}
 }
 
-void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
+void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer)
 {
-#if 0
-	int i;
-	q3mface_t *face;
-	vec3_t modelorg, lightmins, lightmaxs;
-	model_t *model;
-	float projectdistance;
-	projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
-	if (r_drawcollisionbrushes.integer < 2)
-	{
-		model = ent->model;
-		R_Mesh_Matrix(&ent->matrix);
-		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-		lightmins[0] = relativelightorigin[0] - lightradius;
-		lightmins[1] = relativelightorigin[1] - lightradius;
-		lightmins[2] = relativelightorigin[2] - lightradius;
-		lightmaxs[0] = relativelightorigin[0] + lightradius;
-		lightmaxs[1] = relativelightorigin[1] + lightradius;
-		lightmaxs[2] = relativelightorigin[2] + lightradius;
-		//if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
-		//	R_Q3BSP_RecursiveWorldNode(ent, model->brushq3.data_nodes, modelorg, pvs, ++markframe);
-		//else
-			for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
-				if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
-					R_Shadow_VolumeFromSphere(face->num_vertices, face->num_triangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, projectdistance, lightradius);
-	}
-#else
-	int j, t, leafnum, marksurfnum;
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs;
+	int t, leafindex, marksurfaceindex, surfaceindex, triangleindex, outnumclusters = 0, outnumsurfaces = 0;
 	const int *e;
-	const qbyte *pvs;
 	const float *v[3];
-	q3mface_t *face;
+	q3mface_t *surface;
 	q3mleaf_t *leaf;
-	vec3_t modelorg, lightmins, lightmaxs;
-	model_t *model;
-	float projectdistance;
-	projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
-	if (r_drawcollisionbrushes.integer < 2)
+	const qbyte *pvs;
+	lightmins[0] = relativelightorigin[0] - lightradius;
+	lightmins[1] = relativelightorigin[1] - lightradius;
+	lightmins[2] = relativelightorigin[2] - lightradius;
+	lightmaxs[0] = relativelightorigin[0] + lightradius;
+	lightmaxs[1] = relativelightorigin[1] + lightradius;
+	lightmaxs[2] = relativelightorigin[2] + lightradius;
+	*outnumclusterspointer = 0;
+	*outnumsurfacespointer = 0;
+	memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
+	memset(outsurfacepvs, 0, (model->numsurfaces + 7) >> 3);
+	if (model == NULL)
 	{
-		model = ent->model;
-		R_Mesh_Matrix(&ent->matrix);
-		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-		lightmins[0] = relativelightorigin[0] - lightradius;
-		lightmins[1] = relativelightorigin[1] - lightradius;
-		lightmins[2] = relativelightorigin[2] - lightradius;
-		lightmaxs[0] = relativelightorigin[0] + lightradius;
-		lightmaxs[1] = relativelightorigin[1] + lightradius;
-		lightmaxs[2] = relativelightorigin[2] + lightradius;
-		R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
-		if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
-		{	
-			for (leafnum = 0, leaf = ent->model->brushq3.data_leafs;leafnum < ent->model->brushq3.num_leafs;leafnum++, leaf++)
+		VectorCopy(lightmins, outmins);
+		VectorCopy(lightmaxs, outmaxs);
+		return;
+	}
+	VectorCopy(relativelightorigin, outmins);
+	VectorCopy(relativelightorigin, outmaxs);
+	if (model->brush.GetPVS)
+		pvs = model->brush.GetPVS(model, relativelightorigin);
+	else
+		pvs = NULL;
+	// FIXME: use BSP recursion as lights are often small
+	for (leafindex = 0, leaf = model->brushq3.data_leafs;leafindex < model->brushq3.num_leafs;leafindex++, leaf++)
+	{
+		if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && (pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
+		{
+			outmins[0] = min(outmins[0], leaf->mins[0]);
+			outmins[1] = min(outmins[1], leaf->mins[1]);
+			outmins[2] = min(outmins[2], leaf->mins[2]);
+			outmaxs[0] = max(outmaxs[0], leaf->maxs[0]);
+			outmaxs[1] = max(outmaxs[1], leaf->maxs[1]);
+			outmaxs[2] = max(outmaxs[2], leaf->maxs[2]);
+			if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
+			{
+				SETPVSBIT(outclusterpvs, leaf->clusterindex);
+				outclusterlist[outnumclusters++] = leaf->clusterindex;
+			}
+			for (marksurfaceindex = 0;marksurfaceindex < leaf->numleaffaces;marksurfaceindex++)
 			{
-				if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+				surface = leaf->firstleafface[marksurfaceindex];
+				surfaceindex = surface - model->brushq3.data_faces;
+				if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
 				{
-					for (marksurfnum = 0;marksurfnum < leaf->numleaffaces;marksurfnum++)
+					if (BoxesOverlap(lightmins, lightmaxs, surface->mins, surface->maxs))
 					{
-						face = leaf->firstleafface[marksurfnum];
-						if (face->shadowmark != shadowmarkcount)
+						for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->num_triangles;triangleindex++, t++, e += 3)
 						{
-							face->shadowmark = shadowmarkcount;
-							if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
+							v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+							v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+							v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+							if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
 							{
-								for (j = 0, t = face->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < face->num_triangles;j++, t++, e += 3)
-								{
-									v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
-									v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
-									v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
-									if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
-										shadowmarklist[numshadowmark++] = t;
-								}
+								SETPVSBIT(outsurfacepvs, surfaceindex);
+								outsurfacelist[outnumsurfaces++] = surfaceindex;
+								break;
 							}
 						}
 					}
 				}
 			}
 		}
-		else
+	}
+
+	// limit combined leaf box to light boundaries
+	outmins[0] = max(outmins[0], lightmins[0]);
+	outmins[1] = max(outmins[1], lightmins[1]);
+	outmins[2] = max(outmins[2], lightmins[2]);
+	outmaxs[0] = min(outmaxs[0], lightmaxs[0]);
+	outmaxs[1] = min(outmaxs[1], lightmaxs[1]);
+	outmaxs[2] = min(outmaxs[2], lightmaxs[2]);
+
+	*outnumclusterspointer = outnumclusters;
+	*outnumsurfacespointer = outnumsurfaces;
+}
+
+void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
+{
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs;
+	q3mface_t *surface;
+	int surfacelistindex, j, t;
+	const int *e;
+	const float *v[3];
+	if (r_drawcollisionbrushes.integer < 2)
+	{
+		lightmins[0] = relativelightorigin[0] - lightradius;
+		lightmins[1] = relativelightorigin[1] - lightradius;
+		lightmins[2] = relativelightorigin[2] - lightradius;
+		lightmaxs[0] = relativelightorigin[0] + lightradius;
+		lightmaxs[1] = relativelightorigin[1] + lightradius;
+		lightmaxs[2] = relativelightorigin[2] + lightradius;
+		R_Mesh_Matrix(&ent->matrix);
+		R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
+		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
-			for (marksurfnum = 0, face = model->brushq3.data_thismodel->firstface;marksurfnum < model->brushq3.data_thismodel->numfaces;marksurfnum++, face++)
+			surface = model->brushq3.data_faces + surfacelist[surfacelistindex];
+			// FIXME: check some manner of face->rendermode here?
+			if (!(surface->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) && surface->num_triangles && !surface->texture->skin.fog)
 			{
-				if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
+				for (j = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < surface->num_triangles;j++, t++, e += 3)
 				{
-					for (j = 0, t = face->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < face->num_triangles;j++, t++, e += 3)
-					{
-						v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
-						v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
-						v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
-						if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
-							shadowmarklist[numshadowmark++] = t;
-					}
+					v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+					v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+					v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+					if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+						shadowmarklist[numshadowmark++] = t;
 				}
 			}
 		}
-		R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
+		R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius, numshadowmark, shadowmarklist);
 	}
-#endif
 }
 
-void R_Q3BSP_DrawFaceLight(entity_render_t *ent, q3mface_t *face, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
+void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist)
 {
-	if ((face->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) || !face->num_triangles)
-		return;
-	R_Shadow_DiffuseLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, lightcubemap);
-	R_Shadow_SpecularLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, lightcubemap);
-}
-
-void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
-{
-	int leafnum, marksurfnum;
-	const qbyte *pvs;
-	q3mface_t *face;
-	q3mleaf_t *leaf;
-	vec3_t modelorg, lightmins, lightmaxs;
-	model_t *model;
-	//qbyte *pvs;
-	//static int markframe = 0;
+	model_t *model = ent->model;
+	vec3_t lightmins, lightmaxs, modelorg;
+	q3mface_t *surface;
+	int surfacelistindex;
 	if (r_drawcollisionbrushes.integer < 2)
 	{
-		model = ent->model;
-		R_Mesh_Matrix(&ent->matrix);
-		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
 		lightmins[0] = relativelightorigin[0] - lightradius;
 		lightmins[1] = relativelightorigin[1] - lightradius;
 		lightmins[2] = relativelightorigin[2] - lightradius;
 		lightmaxs[0] = relativelightorigin[0] + lightradius;
 		lightmaxs[1] = relativelightorigin[1] + lightradius;
 		lightmaxs[2] = relativelightorigin[2] + lightradius;
-
-		if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
-		{	
-			pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
-			for (leafnum = 0, leaf = ent->model->brushq3.data_leafs;leafnum < ent->model->brushq3.num_leafs;leafnum++, leaf++)
+		R_Mesh_Matrix(&ent->matrix);
+		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
+		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
+		{
+			surface = model->brushq3.data_faces + surfacelist[surfacelistindex];
+			if (r_shadow_compilingrtlight)
 			{
-				if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
-				{
-					for (marksurfnum = 0;marksurfnum < leaf->numleaffaces;marksurfnum++)
-					{
-						face = leaf->firstleafface[marksurfnum];
-						if (face->shadowmark != shadowmarkcount)
-						{
-							face->shadowmark = shadowmarkcount;
-							if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs) && (ent != &cl_entities[0].render || face->visframe == r_framecount))
-								R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, lightcubemap);
-						}
-					}
-				}
+				// if compiling an rtlight, capture the mesh
+				Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_light, surface->texture->skin.base, surface->texture->skin.gloss, surface->texture->skin.nmap, surface->data_vertex3f, surface->data_svector3f, surface->data_tvector3f, surface->data_normal3f, surface->data_texcoordtexture2f, surface->num_triangles, surface->data_element3i);
 			}
-		}
-		else
-		{
-			for (marksurfnum = 0, face = model->brushq3.data_thismodel->firstface;marksurfnum < model->brushq3.data_thismodel->numfaces;marksurfnum++, face++)
-				if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs) && (ent != &cl_entities[0].render || face->visframe == r_framecount))
-					R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, lightcubemap);
+			else if ((ent != &cl_entities[0].render || surface->visframe == r_framecount) && !(surface->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) && surface->num_triangles)
+				R_Shadow_RenderLighting(surface->num_vertices, surface->num_triangles, surface->data_element3i, surface->data_vertex3f, surface->data_svector3f, surface->data_tvector3f, surface->data_normal3f, surface->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, surface->texture->skin.base, surface->texture->skin.nmap, surface->texture->skin.gloss, lightcubemap, LIGHTING_DIFFUSE | LIGHTING_SPECULAR);
 		}
 	}
 }