X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_rsurf.c;h=2f41c8671f3cf2fddeedc12e2ae82fced1bab36f;hp=3b3622d33c4a19c558c85eb1d7fe62e8359469e5;hb=d0afea73454a0e381e2becf7e8c861c146908030;hpb=a7f3098c45daeb30e23bdc6412cf1512ab1927c6

diff --git a/gl_rsurf.c b/gl_rsurf.c
index 3b3622d3..2f41c867 100644
--- a/gl_rsurf.c
+++ b/gl_rsurf.c
@@ -37,6 +37,7 @@ cvar_t r_detailtextures = {CVAR_SAVE, "r_detailtextures", "1"};
 cvar_t r_surfaceworldnode = {0, "r_surfaceworldnode", "1"};
 cvar_t r_drawcollisionbrushes_polygonfactor = {0, "r_drawcollisionbrushes_polygonfactor", "-1"};
 cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0"};
+cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0"};
 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
 
 /*
@@ -54,7 +55,7 @@ int r_q3bsp_nummarkleafs;
 q3mleaf_t *r_q3bsp_maxleaflist[65536];
 int r_q3bsp_maxmarksurfaces;
 int r_q3bsp_nummarksurfaces;
-q3mface_t *r_q3bsp_maxsurfacelist[65536];
+q3msurface_t *r_q3bsp_maxsurfacelist[65536];
 */
 
 static int dlightdivtable[32768];
@@ -279,14 +280,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 		else
 		{
 	// clear to no light
-			j = r_ambient.value * 512.0f; // would be 128.0f logically, but using 512.0f to match winquake style
-			if (j)
-			{
-				for (i = 0;i < size3;i++)
-					*bl++ = j;
-			}
-			else
-				memset(bl, 0, size*3*sizeof(unsigned int));
+			memset(bl, 0, size*3*sizeof(unsigned int));
 
 			if (surf->dlightframe == r_framecount)
 			{
@@ -360,33 +354,29 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 	// set to full bright if no light data
 		bl = floatblocklights;
 		if (!ent->model->brushq1.lightdata)
-			j = 255*256;
-		else
-			j = r_ambient.value * 512.0f; // would be 128.0f logically, but using 512.0f to match winquake style
-
-		// clear to no light
-		if (j)
 		{
 			for (i = 0;i < size3;i++)
-				*bl++ = j;
+				bl[i] = 255*256;
 		}
 		else
-			memset(bl, 0, size*3*sizeof(float));
-
-		if (surf->dlightframe == r_framecount)
 		{
-			surf->cached_dlight = R_FloatAddDynamicLights(&ent->inversematrix, surf);
-			if (surf->cached_dlight)
-				c_light_polys++;
-		}
-
-		// add all the lightmaps
-		if (lightmap)
-		{
-			bl = floatblocklights;
-			for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++, lightmap += size3)
-				for (scale = d_lightstylevalue[surf->styles[maps]], i = 0;i < size3;i++)
-					bl[i] += lightmap[i] * scale;
+			memset(bl, 0, size*3*sizeof(float));
+	
+			if (surf->dlightframe == r_framecount)
+			{
+				surf->cached_dlight = R_FloatAddDynamicLights(&ent->inversematrix, surf);
+				if (surf->cached_dlight)
+					c_light_polys++;
+			}
+	
+			// add all the lightmaps
+			if (lightmap)
+			{
+				bl = floatblocklights;
+				for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++, lightmap += size3)
+					for (scale = d_lightstylevalue[surf->styles[maps]], i = 0;i < size3;i++)
+						bl[i] += lightmap[i] * scale;
+			}
 		}
 
 		stain = surf->stainsamples;
@@ -777,22 +767,29 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
 	GL_ColorMask(1,1,1,1);
 }
 
-static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
+static void RSurfShader_Transparent_Callback(const void *calldata1, int calldata2)
 {
 	const entity_render_t *ent = calldata1;
 	const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
 	rmeshstate_t m;
 	float currentalpha;
-	float modelorg[3];
+	float base, colorscale;
+	vec3_t modelorg;
 	texture_t *texture;
 	float args[4] = {0.05f,0,0,0.04f};
-	int rendertype;
+	int rendertype, turb, fullbright;
 
 	R_Mesh_Matrix(&ent->matrix);
 	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
 
-	texture = surf->texinfo->texture->currentframe;
-	currentalpha = texture->currentalpha;
+	texture = surf->texinfo->texture;
+	if (texture->animated)
+		texture = texture->anim_frames[ent->frame != 0][(texture->anim_total[ent->frame != 0] >= 2) ? ((int) (cl.time * 5.0f) % texture->anim_total[ent->frame != 0]) : 0];
+	currentalpha = ent->alpha;
+	if (surf->flags & SURF_WATERALPHA)
+		currentalpha *= r_wateralpha.value;
+
+	GL_DepthTest(true);
 	if (ent->effects & EF_ADDITIVE)
 	{
 		rendertype = SURFRENDER_ADD;
@@ -811,12 +808,18 @@ 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, currentalpha);
-	memset(&m, 0, sizeof(m));
-	m.pointer_vertex = surf->mesh.data_vertex3f;
-	if (gl_textureshader && r_watershader.value && !fogenabled)
+
+	turb = (surf->flags & SURF_DRAWTURB) && r_waterscroll.value;
+	fullbright = (ent->effects & EF_FULLBRIGHT) || (surf->flags & SURF_DRAWFULLBRIGHT) || !surf->samples;
+	base = fullbright ? 2.0f : r_ambient.value * (1.0f / 64.0f);
+	if (surf->flags & SURF_DRAWTURB)
+		base *= 0.5f;
+	if ((surf->flags & SURF_DRAWTURB) && gl_textureshader && r_watershader.value && !fogenabled)
 	{
+		// NVIDIA Geforce3 distortion texture shader on water
+		GL_Color(1, 1, 1, currentalpha);
+		memset(&m, 0, sizeof(m));
+		m.pointer_vertex = surf->mesh.data_vertex3f;
 		m.tex[0] = R_GetTexture(mod_shared_distorttexture[(int)(cl.time * 16)&63]);
 		m.tex[1] = R_GetTexture(texture->skin.base);
 		m.texcombinergb[0] = GL_REPLACE;
@@ -845,129 +848,81 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 	}
 	else
 	{
-		RSurf_FoggedColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, 1, 1, currentalpha, 1, surf->mesh.num_vertices, modelorg);
+		memset(&m, 0, sizeof(m));
+		m.pointer_vertex = surf->mesh.data_vertex3f;
 		m.pointer_color = varray_color4f;
-		m.tex[0] = R_GetTexture(texture->skin.base);
 		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-		if (r_waterscroll.value)
+		m.tex[0] = R_GetTexture(texture->skin.base);
+		if (turb)
 		{
 			// 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 (fogenabled && 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], currentalpha, 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);
-		}
-	}
-}
-
-static void RSurfShader_Wall_Vertex_Callback(const void *calldata1, int calldata2)
-{
-	const entity_render_t *ent = calldata1;
-	const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
-	int rendertype;
-	float currentalpha;
-	texture_t *texture;
-	float base, colorscale;
-	rmeshstate_t m;
-	vec3_t modelorg;
-	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-	R_Mesh_Matrix(&ent->matrix);
-
-	texture = surf->texinfo->texture;
-	if (texture->animated)
-		texture = texture->anim_frames[ent->frame != 0][(texture->anim_total[ent->frame != 0] >= 2) ? ((int) (cl.time * 5.0f) % texture->anim_total[ent->frame != 0]) : 0];
-
-	currentalpha = ent->alpha;
-	base = ent->effects & EF_FULLBRIGHT ? 2.0f : r_ambient.value * (1.0f / 64.0f);
-	GL_DepthTest(true);
-	if (ent->effects & EF_ADDITIVE)
-	{
-		rendertype = SURFRENDER_ADD;
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		GL_DepthMask(false);
-	}
-	else if (currentalpha < 1 || texture->skin.fog != NULL)
-	{
-		rendertype = SURFRENDER_ALPHA;
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		GL_DepthMask(false);
-	}
-	else
-	{
-		rendertype = SURFRENDER_OPAQUE;
-		GL_BlendFunc(GL_ONE, GL_ZERO);
-		GL_DepthMask(true);
-	}
-
-	{
-		memset(&m, 0, sizeof(m));
-		m.tex[0] = R_GetTexture(texture->skin.base);
 		colorscale = 1;
 		if (gl_combine.integer)
 		{
 			m.texrgbscale[0] = 4;
 			colorscale *= 0.25f;
 		}
-		m.pointer_color = varray_color4f;
-		m.pointer_vertex = surf->mesh.data_vertex3f;
-		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-		R_Mesh_State(&m);
 		R_FillColors(varray_color4f, surf->mesh.num_vertices, base, base, base, currentalpha);
-		if (!(ent->effects & EF_FULLBRIGHT))
+		if (!fullbright)
 		{
 			if (surf->dlightframe == r_framecount)
 				RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, surf->mesh.num_vertices, surf->mesh.data_vertex3f, varray_color4f, 1);
-			if (surf->flags & SURF_LIGHTMAP)
+			if (surf->samples)
 				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);
-	}
-	if (texture->skin.glow)
-	{
-		memset(&m, 0, sizeof(m));
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		GL_DepthMask(false);
-		m.pointer_color = varray_color4f;
-		m.tex[0] = R_GetTexture(texture->skin.glow);
-		m.pointer_vertex = surf->mesh.data_vertex3f;
-		if (m.tex[0])
-			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
 		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);
-	}
-	if (fogenabled && rendertype != SURFRENDER_ADD)
-	{
-		memset(&m, 0, sizeof(m));
-		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		GL_DepthMask(false);
-		m.pointer_color = varray_color4f;
-		m.tex[0] = R_GetTexture(texture->skin.fog);
-		m.pointer_vertex = surf->mesh.data_vertex3f;
-		if (m.tex[0])
-			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
-		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);
+		if (texture->skin.glow)
+		{
+			memset(&m, 0, sizeof(m));
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+			GL_DepthMask(false);
+			m.pointer_color = varray_color4f;
+			m.tex[0] = R_GetTexture(texture->skin.glow);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
+			if (m.tex[0])
+			{
+				m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+				if (turb)
+				{
+					// 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);
+			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);
+		}
+		if (fogenabled && rendertype != SURFRENDER_ADD)
+		{
+			memset(&m, 0, sizeof(m));
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+			GL_DepthMask(false);
+			m.pointer_color = varray_color4f;
+			m.tex[0] = R_GetTexture(texture->skin.fog);
+			m.pointer_vertex = surf->mesh.data_vertex3f;
+			if (m.tex[0])
+			{
+				m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+				if (turb)
+				{
+					// 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);
+			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);
+		}
 	}
 }
 
@@ -1138,6 +1093,30 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 	}
 }
 
+static void RSurfShader_OpaqueWall_Pass_BaseAmbient(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
+{
+	const msurface_t *surf;
+	rmeshstate_t m;
+	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.base);
+	GL_Color(r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), 1);
+	while((surf = *surfchain++) != NULL)
+	{
+		if (surf->visframe == r_framecount)
+		{
+			m.pointer_vertex = surf->mesh.data_vertex3f;
+			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+			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);
+		}
+	}
+}
+
 static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
@@ -1271,97 +1250,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(const entity_render_t *
 	}
 }
 
-static void R_DrawSurfaceChain(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
-{
-	const msurface_t *surf;
-	msurface_t **chain;
-	vec3_t center;
-	if (texture->flags & SURF_LIGHTMAP)
-	{
-		if (gl_lightmaps.integer)
-		{
-			RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-		else if (texture->rendertype != SURFRENDER_OPAQUE)
-		{
-			// transparent vertex shaded from lightmap
-			for (chain = surfchain;(surf = *chain) != NULL;chain++)
-			{
-				if (surf->visframe == r_framecount)
-				{
-					Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
-					R_MeshQueue_AddTransparent(center, RSurfShader_Wall_Vertex_Callback, ent, surf - ent->model->brushq1.surfaces);
-				}
-			}
-		}
-		else if (ent->effects & EF_FULLBRIGHT)
-		{
-			RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
-			if (r_detailtextures.integer)
-				RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
-			if (texture->skin.glow)
-				RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-		else if (r_textureunits.integer >= 4 && gl_combine.integer && r_detailtextures.integer)
-		{
-			RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-		else if (r_textureunits.integer >= 3 && gl_combine.integer && r_detailtextures.integer)
-		{
-			RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetail(ent, texture, surfchain);
-			if (texture->skin.glow)
-				RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-		else if (r_textureunits.integer >= 2 && gl_combine.integer)
-		{
-			RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmap(ent, texture, surfchain);
-			if (r_detailtextures.integer)
-				RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
-			if (texture->skin.glow)
-				RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-		else
-		{
-			RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
-			RSurfShader_OpaqueWall_Pass_BaseLightmap(ent, texture, surfchain);
-			if (r_detailtextures.integer)
-				RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
-			if (texture->skin.glow)
-				RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
-			if (fogenabled)
-				RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
-		}
-	}
-	else if (texture->flags & SURF_DRAWTURB)
-	{
-		for (chain = surfchain;(surf = *chain) != NULL;chain++)
-		{
-			if (surf->visframe == r_framecount)
-			{
-				if (texture->rendertype == SURFRENDER_OPAQUE)
-					RSurfShader_Water_Callback(ent, surf - ent->model->brushq1.surfaces);
-				else
-				{
-					Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
-					R_MeshQueue_AddTransparent(center, RSurfShader_Water_Callback, ent, surf - ent->model->brushq1.surfaces);
-				}
-			}
-		}
-	}
-	else if (texture->flags & SURF_DRAWSKY)
-		RSurfShader_Sky(ent, texture, surfchain);
-}
-
 void R_UpdateTextureInfo(entity_render_t *ent)
 {
 	int i, texframe, alttextures;
@@ -1391,11 +1279,31 @@ void R_UpdateTextureInfo(entity_render_t *ent)
 	}
 }
 
+void R_UpdateLightmapInfo(entity_render_t *ent)
+{
+	int i;
+	msurface_t *surface, **surfacechain;
+	model_t *model = ent->model;
+	if (!model)
+		return;
+	if (r_dynamic.integer && !r_shadow_realtime_dlight.integer)
+		R_MarkLights(ent);
+	for (i = 0;i < model->brushq1.light_styles;i++)
+	{
+		if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
+		{
+			model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
+			for (surfacechain = model->brushq1.light_styleupdatechains[i];(surface = *surfacechain);surfacechain++)
+				surface->cached_dlight = true;
+		}
+	}
+}
+
 void R_PrepareSurfaces(entity_render_t *ent)
 {
 	int i, numsurfaces, *surfacevisframes;
 	model_t *model;
-	msurface_t *surf, *surfaces, **surfchain;
+	msurface_t *surf, *surfaces;
 	vec3_t modelorg;
 
 	if (!ent->model)
@@ -1403,34 +1311,9 @@ void R_PrepareSurfaces(entity_render_t *ent)
 
 	model = ent->model;
 	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
-	numsurfaces = model->brushq1.nummodelsurfaces;
-	surfaces = model->brushq1.surfaces + model->brushq1.firstmodelsurface;
-	surfacevisframes = model->brushq1.surfacevisframes + model->brushq1.firstmodelsurface;
-
-	R_UpdateTextureInfo(ent);
-
-	if (r_dynamic.integer && !r_shadow_realtime_dlight.integer)
-		R_MarkLights(ent);
-
-	if (model->brushq1.light_ambient != r_ambient.value)
-	{
-		model->brushq1.light_ambient = r_ambient.value;
-		for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
-			model->brushq1.surfaces[i + model->brushq1.firstmodelsurface].cached_dlight = true;
-	}
-	else
-	{
-		for (i = 0;i < model->brushq1.light_styles;i++)
-		{
-			if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
-			{
-				model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
-				for (surfchain = model->brushq1.light_styleupdatechains[i];*surfchain;surfchain++)
-					(**surfchain).cached_dlight = true;
-			}
-		}
-	}
-
+	numsurfaces = model->nummodelsurfaces;
+	surfaces = model->brushq1.surfaces + model->firstmodelsurface;
+	surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
 	for (i = 0, surf = surfaces;i < numsurfaces;i++, surf++)
 	{
 		if (surfacevisframes[i] == r_framecount)
@@ -1461,17 +1344,94 @@ void R_PrepareSurfaces(entity_render_t *ent)
 
 void R_DrawSurfaces(entity_render_t *ent, int flagsmask)
 {
-	int i, f;
-	texture_t *t;
+	int texturenumber, f;
+	vec3_t center;
+	msurface_t *surf, **chain, **surfchain;
+	texture_t *t, *texture;
 	model_t *model = ent->model;
 	if (model == NULL)
 		return;
 	R_Mesh_Matrix(&ent->matrix);
-	for (i = 0, t = model->brushq1.textures;i < model->brushq1.numtextures;i++, t++)
+	for (texturenumber = 0, t = model->brushq1.textures;texturenumber < model->brushq1.numtextures;texturenumber++, t++)
 	{
-		f = t->flags & flagsmask;
-		if (f && t->currentframe && model->brushq1.pvstexturechains[i] != NULL)
-			R_DrawSurfaceChain(ent, t->currentframe, model->brushq1.pvstexturechains[i]);
+		if ((f = t->flags & flagsmask) && (texture = t->currentframe) && (surfchain = model->brushq1.pvstexturechains[texturenumber]) != NULL)
+		{
+			if (texture->flags & SURF_LIGHTMAP)
+			{
+				if (gl_lightmaps.integer)
+				{
+					RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(ent, texture, surfchain);
+					if (fogenabled)
+						RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
+				}
+				else if (texture->rendertype != SURFRENDER_OPAQUE)
+				{
+					// transparent vertex shaded from lightmap
+					for (chain = surfchain;(surf = *chain) != NULL;chain++)
+					{
+						if (surf->visframe == r_framecount)
+						{
+							Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
+							R_MeshQueue_AddTransparent(center, RSurfShader_Transparent_Callback, ent, surf - ent->model->brushq1.surfaces);
+						}
+					}
+				}
+				else
+				{
+					if (ent->effects & EF_FULLBRIGHT || r_fullbright.integer)
+					{
+						RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
+						if (r_detailtextures.integer)
+							RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
+						if (texture->skin.glow)
+							RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
+					}
+					else if (r_textureunits.integer >= 4 && gl_combine.integer && r_detailtextures.integer && r_ambient.value <= 0)
+						RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(ent, texture, surfchain);
+					else
+					{
+						if (r_textureunits.integer >= 3 && gl_combine.integer && r_detailtextures.integer && r_ambient.value <= 0)
+							RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetail(ent, texture, surfchain);
+						else
+						{
+							if (r_textureunits.integer >= 2 && gl_combine.integer)
+								RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmap(ent, texture, surfchain);
+							else
+							{
+								RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
+								RSurfShader_OpaqueWall_Pass_BaseLightmap(ent, texture, surfchain);
+							}
+							if (r_ambient.value > 0)
+								RSurfShader_OpaqueWall_Pass_BaseAmbient(ent, texture, surfchain);
+							if (r_detailtextures.integer)
+								RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
+						}
+						if (texture->skin.glow)
+							RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
+					}
+					if (fogenabled)
+						RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
+				}
+			}
+			else if (texture->flags & SURF_DRAWTURB)
+			{
+				for (chain = surfchain;(surf = *chain) != NULL;chain++)
+				{
+					if (surf->visframe == r_framecount)
+					{
+						if (texture->rendertype == SURFRENDER_OPAQUE)
+							RSurfShader_Transparent_Callback(ent, surf - ent->model->brushq1.surfaces);
+						else
+						{
+							Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
+							R_MeshQueue_AddTransparent(center, RSurfShader_Transparent_Callback, ent, surf - ent->model->brushq1.surfaces);
+						}
+					}
+				}
+			}
+			else if (texture->flags & SURF_DRAWSKY)
+				RSurfShader_Sky(ent, texture, surfchain);
+		}
 	}
 }
 
@@ -1549,10 +1509,10 @@ void R_PrepareBrushModel(entity_render_t *ent)
 #if WORLDNODECULLBACKFACES
 	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
 #endif
-	numsurfaces = model->brushq1.nummodelsurfaces;
-	surf = model->brushq1.surfaces + model->brushq1.firstmodelsurface;
-	surfacevisframes = model->brushq1.surfacevisframes + model->brushq1.firstmodelsurface;
-	surfacepvsframes = model->brushq1.surfacepvsframes + model->brushq1.firstmodelsurface;
+	numsurfaces = model->nummodelsurfaces;
+	surf = model->brushq1.surfaces + model->firstmodelsurface;
+	surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
+	surfacepvsframes = model->brushq1.surfacepvsframes + model->firstmodelsurface;
 	for (i = 0;i < numsurfaces;i++, surf++)
 	{
 #if WORLDNODECULLBACKFACES
@@ -1569,7 +1529,8 @@ void R_PrepareBrushModel(entity_render_t *ent)
 #endif
 		surf->dlightframe = -1;
 	}
-	R_PrepareSurfaces(ent);
+	R_UpdateTextureInfo(ent);
+	R_UpdateLightmapInfo(ent);
 }
 
 void R_SurfaceWorldNode (entity_render_t *ent)
@@ -1584,8 +1545,8 @@ void R_SurfaceWorldNode (entity_render_t *ent)
 	model = ent->model;
 	if (model == NULL)
 		return;
-	surfacevisframes = model->brushq1.surfacevisframes + model->brushq1.firstmodelsurface;
-	surfacepvsframes = model->brushq1.surfacepvsframes + model->brushq1.firstmodelsurface;
+	surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
+	surfacepvsframes = model->brushq1.surfacepvsframes + model->firstmodelsurface;
 	Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
 
 	for (leaf = model->brushq1.pvsleafchain;leaf;leaf = leaf->pvschain)
@@ -1743,49 +1704,35 @@ void R_WorldVisibility(entity_render_t *ent)
 		R_SurfaceWorldNode (ent);
 	else
 		R_PortalWorldNode (ent, viewleaf);
-}
 
-void R_DrawWorld(entity_render_t *ent)
-{
-	if (ent->model == NULL)
-		return;
-	if (!ent->model->brushq1.num_leafs)
-	{
-		if (ent->model->DrawSky)
-			ent->model->DrawSky(ent);
-		if (ent->model->Draw)
-			ent->model->Draw(ent);
-	}
-	else
-	{
-		R_PrepareSurfaces(ent);
-		R_DrawSurfaces(ent, SURF_DRAWSKY);
-		R_DrawSurfaces(ent, SURF_DRAWTURB | SURF_LIGHTMAP);
-		if (r_drawportals.integer)
-			R_DrawPortals(ent);
-	}
+	if (r_drawportals.integer)
+		R_DrawPortals(ent);
 }
 
-void R_Model_Brush_DrawSky(entity_render_t *ent)
+void R_Q1BSP_DrawSky(entity_render_t *ent)
 {
 	if (ent->model == NULL)
 		return;
 	if (ent != &cl_entities[0].render)
 		R_PrepareBrushModel(ent);
+	R_PrepareSurfaces(ent);
 	R_DrawSurfaces(ent, SURF_DRAWSKY);
 }
 
-void R_Model_Brush_Draw(entity_render_t *ent)
+void R_Q1BSP_Draw(entity_render_t *ent)
 {
 	if (ent->model == NULL)
 		return;
 	c_bmodels++;
 	if (ent != &cl_entities[0].render)
 		R_PrepareBrushModel(ent);
+	R_PrepareSurfaces(ent);
+	R_UpdateTextureInfo(ent);
+	R_UpdateLightmapInfo(ent);
 	R_DrawSurfaces(ent, SURF_DRAWTURB | SURF_LIGHTMAP);
 }
 
-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)
+void R_Q1BSP_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)
 {
 	model_t *model = ent->model;
 	vec3_t lightmins, lightmaxs;
@@ -1804,7 +1751,7 @@ void R_Model_Brush_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin
 	*outnumclusterspointer = 0;
 	*outnumsurfacespointer = 0;
 	memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
-	memset(outsurfacepvs, 0, (model->numsurfaces + 7) >> 3);
+	memset(outsurfacepvs, 0, (model->nummodelsurfaces + 7) >> 3);
 	if (model == NULL)
 	{
 		VectorCopy(lightmins, outmins);
@@ -1828,29 +1775,35 @@ void R_Model_Brush_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin
 			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))
+			if (outclusterpvs)
 			{
-				SETPVSBIT(outclusterpvs, leaf->clusterindex);
-				outclusterlist[outnumclusters++] = leaf->clusterindex;
+				if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
+				{
+					SETPVSBIT(outclusterpvs, leaf->clusterindex);
+					outclusterlist[outnumclusters++] = leaf->clusterindex;
+				}
 			}
-			for (marksurfaceindex = 0;marksurfaceindex < leaf->nummarksurfaces;marksurfaceindex++)
+			if (outsurfacepvs)
 			{
-				surfaceindex = leaf->firstmarksurface[marksurfaceindex];
-				if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
+				for (marksurfaceindex = 0;marksurfaceindex < leaf->nummarksurfaces;marksurfaceindex++)
 				{
-					surface = model->brushq1.surfaces + surfaceindex;
-					if (BoxesOverlap(lightmins, lightmaxs, surface->poly_mins, surface->poly_maxs))
+					surfaceindex = leaf->firstmarksurface[marksurfaceindex];
+					if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
 					{
-						for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->mesh.num_triangles;triangleindex++, t++, e += 3)
+						surface = model->brushq1.surfaces + surfaceindex;
+						if (BoxesOverlap(lightmins, lightmaxs, surface->poly_mins, surface->poly_maxs) && (surface->flags & SURF_LIGHTMAP) && !surface->texinfo->texture->skin.fog)
 						{
-							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 (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->mesh.num_triangles;triangleindex++, t++, e += 3)
 							{
-								SETPVSBIT(outsurfacepvs, surfaceindex);
-								outsurfacelist[outnumsurfaces++] = surfaceindex;
-								break;
+								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])))
+								{
+									SETPVSBIT(outsurfacepvs, surfaceindex);
+									outsurfacelist[outnumsurfaces++] = surfaceindex;
+									break;
+								}
 							}
 						}
 					}
@@ -1871,7 +1824,7 @@ void R_Model_Brush_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin
 	*outnumsurfacespointer = outnumsurfaces;
 }
 
-void R_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
+void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
 {
 	model_t *model = ent->model;
 	vec3_t lightmins, lightmaxs;
@@ -1901,11 +1854,11 @@ void R_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightor
 					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(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + r_shadow_projectdistance.value, numshadowmark, shadowmarklist);
 	}
 }
 
-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)
+void R_Q1BSP_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)
 {
 	model_t *model = ent->model;
 	vec3_t lightmins, lightmaxs, modelorg;
@@ -1922,6 +1875,7 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 		lightmaxs[2] = relativelightorigin[2] + lightradius;
 		R_Mesh_Matrix(&ent->matrix);
 		Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
+		R_UpdateTextureInfo(ent);
 		for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
 			surface = model->brushq1.surfaces + surfacelist[surfacelistindex];
@@ -1956,7 +1910,7 @@ void R_DrawCollisionBrush(colbrushf_t *brush)
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawCollisionFace(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawCollisionFace(entity_render_t *ent, q3msurface_t *face)
 {
 	int i;
 	rmeshstate_t m;
@@ -1965,14 +1919,14 @@ void R_Q3BSP_DrawCollisionFace(entity_render_t *ent, q3mface_t *face)
 	memset(&m, 0, sizeof(m));
 	m.pointer_vertex = face->data_collisionvertex3f;
 	R_Mesh_State(&m);
-	i = ((int)face) / sizeof(q3mface_t);
+	i = ((int)face) / sizeof(q3msurface_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_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)
+void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	if (!face->num_triangles)
@@ -1984,6 +1938,8 @@ void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3mface_t *face)
 		if (skyrendermasked)
 			R_Sky();
 	}
+	if (!r_q3bsp_renderskydepth.integer)
+		return;
 
 	R_Mesh_Matrix(&ent->matrix);
 
@@ -2014,7 +1970,7 @@ void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3mface_t *face)
 	GL_ColorMask(1,1,1,1);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2036,7 +1992,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(entity_render_t *ent, q3mface_t
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2056,7 +2012,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *en
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2073,7 +2029,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3mface_t *f
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2090,7 +2046,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3mface_t *
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2110,7 +2066,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3mface
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2132,7 +2088,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3mface_t *face
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3msurface_t *face)
 {
 	int i;
 	float mul;
@@ -2171,7 +2127,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3mfac
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3msurface_t *face)
 {
 	int i;
 	float mul;
@@ -2203,7 +2159,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3mface_t
 	GL_LockArrays(0, 0);
 }
 
-void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3msurface_t *face)
 {
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
@@ -2223,7 +2179,7 @@ void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3
 void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
 {
 	const entity_render_t *ent = voident;
-	q3mface_t *face = ent->model->brushq3.data_faces + facenumber;
+	q3msurface_t *face = ent->model->brushq3.data_faces + facenumber;
 	rmeshstate_t m;
 	R_Mesh_Matrix(&ent->matrix);
 	memset(&m, 0, sizeof(m));
@@ -2284,15 +2240,12 @@ void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
 	qglEnable(GL_CULL_FACE);
 }
 
-void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
+void R_Q3BSP_DrawFace(entity_render_t *ent, q3msurface_t *face)
 {
 	if (!face->num_triangles)
 		return;
-	if (face->texture->surfaceparms)
-	{
-		if (face->texture->surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NODRAW))
-			return;
-	}
+	if (face->texture->surfaceflags && (face->texture->surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NODRAW)))
+		return;
 	c_faces++;
 	if ((face->texture->surfaceparms & Q3SURFACEPARM_TRANS) || ent->alpha < 1 || (ent->effects & EF_ADDITIVE))
 	{
@@ -2392,7 +2345,7 @@ static int r_q3bsp_framecount = -1;
 void R_Q3BSP_DrawSky(entity_render_t *ent)
 {
 	int i;
-	q3mface_t *face;
+	q3msurface_t *face;
 	vec3_t modelorg;
 	model_t *model;
 	R_Mesh_Matrix(&ent->matrix);
@@ -2422,7 +2375,7 @@ void R_Q3BSP_DrawSky(entity_render_t *ent)
 void R_Q3BSP_Draw(entity_render_t *ent)
 {
 	int i;
-	q3mface_t *face;
+	q3msurface_t *face;
 	vec3_t modelorg;
 	model_t *model;
 	qbyte *pvs;
@@ -2471,7 +2424,7 @@ void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, floa
 	int t, leafindex, marksurfaceindex, surfaceindex, triangleindex, outnumclusters = 0, outnumsurfaces = 0;
 	const int *e;
 	const float *v[3];
-	q3mface_t *surface;
+	q3msurface_t *surface;
 	q3mleaf_t *leaf;
 	const qbyte *pvs;
 	lightmins[0] = relativelightorigin[0] - lightradius;
@@ -2483,7 +2436,7 @@ void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, floa
 	*outnumclusterspointer = 0;
 	*outnumsurfacespointer = 0;
 	memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
-	memset(outsurfacepvs, 0, (model->numsurfaces + 7) >> 3);
+	memset(outsurfacepvs, 0, (model->nummodelsurfaces + 7) >> 3);
 	if (model == NULL)
 	{
 		VectorCopy(lightmins, outmins);
@@ -2507,29 +2460,35 @@ void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, floa
 			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))
+			if (outclusterpvs)
 			{
-				SETPVSBIT(outclusterpvs, leaf->clusterindex);
-				outclusterlist[outnumclusters++] = leaf->clusterindex;
+				if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
+				{
+					SETPVSBIT(outclusterpvs, leaf->clusterindex);
+					outclusterlist[outnumclusters++] = leaf->clusterindex;
+				}
 			}
-			for (marksurfaceindex = 0;marksurfaceindex < leaf->numleaffaces;marksurfaceindex++)
+			if (outsurfacepvs)
 			{
-				surface = leaf->firstleafface[marksurfaceindex];
-				surfaceindex = surface - model->brushq3.data_faces;
-				if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
+				for (marksurfaceindex = 0;marksurfaceindex < leaf->numleaffaces;marksurfaceindex++)
 				{
-					if (BoxesOverlap(lightmins, lightmaxs, surface->mins, surface->maxs))
+					surface = leaf->firstleafface[marksurfaceindex];
+					surfaceindex = surface - model->brushq3.data_faces;
+					if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
 					{
-						for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->num_triangles;triangleindex++, t++, e += 3)
+						if (BoxesOverlap(lightmins, lightmaxs, surface->mins, surface->maxs) && !(surface->texture->surfaceparms & Q3SURFACEPARM_TRANS) && !(surface->texture->surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NODRAW)))
 						{
-							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 (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->num_triangles;triangleindex++, t++, e += 3)
 							{
-								SETPVSBIT(outsurfacepvs, surfaceindex);
-								outsurfacelist[outnumsurfaces++] = surfaceindex;
-								break;
+								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])))
+								{
+									SETPVSBIT(outsurfacepvs, surfaceindex);
+									outsurfacelist[outnumsurfaces++] = surfaceindex;
+									break;
+								}
 							}
 						}
 					}
@@ -2554,7 +2513,7 @@ void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin,
 {
 	model_t *model = ent->model;
 	vec3_t lightmins, lightmaxs;
-	q3mface_t *surface;
+	q3msurface_t *surface;
 	int surfacelistindex, j, t;
 	const int *e;
 	const float *v[3];
@@ -2584,7 +2543,7 @@ void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin,
 				}
 			}
 		}
-		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(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + r_shadow_projectdistance.value, numshadowmark, shadowmarklist);
 	}
 }
 
@@ -2592,7 +2551,7 @@ void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t
 {
 	model_t *model = ent->model;
 	vec3_t lightmins, lightmaxs, modelorg;
-	q3mface_t *surface;
+	q3msurface_t *surface;
 	int surfacelistindex;
 	if (r_drawcollisionbrushes.integer < 2)
 	{
@@ -2645,6 +2604,7 @@ void GL_Surf_Init(void)
 	Cvar_RegisterVariable(&r_surfaceworldnode);
 	Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonfactor);
 	Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonoffset);
+	Cvar_RegisterVariable(&r_q3bsp_renderskydepth);
 	Cvar_RegisterVariable(&gl_lightmaps);
 
 	R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);