X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rsurf.c;h=50086102629f961f50fdc8540f35abcfeb3bc0e9;hb=296d6736cc8fdd937c1f99b38c3ca97cddc7c9e9;hp=35b582a57d8038a139ef3ea817f9b1636d42a234;hpb=50ad2c94eefa8226b5568d89859651bb7ee75c88;p=xonotic%2Fdarkplaces.git

diff --git a/gl_rsurf.c b/gl_rsurf.c
index 35b582a5..50086102 100644
--- a/gl_rsurf.c
+++ b/gl_rsurf.c
@@ -30,13 +30,12 @@ static float floatblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHav
 static qbyte templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4];
 
 cvar_t r_ambient = {0, "r_ambient", "0"};
-cvar_t r_vertexsurfaces = {0, "r_vertexsurfaces", "0"};
-cvar_t r_dlightmap = {CVAR_SAVE, "r_dlightmap", "1"};
 cvar_t r_drawportals = {0, "r_drawportals", "0"};
 cvar_t r_testvis = {0, "r_testvis", "0"};
 cvar_t r_floatbuildlightmap = {0, "r_floatbuildlightmap", "0"};
 cvar_t r_detailtextures = {CVAR_SAVE, "r_detailtextures", "1"};
 cvar_t r_surfaceworldnode = {0, "r_surfaceworldnode", "1"};
+cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "-4"};
 
 static int dlightdivtable[32768];
 
@@ -250,7 +249,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 
 	// set to full bright if no light data
 		bl = intblocklights;
-		if ((ent->effects & EF_FULLBRIGHT) || !ent->model->lightdata)
+		if ((ent->effects & EF_FULLBRIGHT) || !ent->model->brushq1.lightdata)
 		{
 			for (i = 0;i < size3;i++)
 				bl[i] = 255*256;
@@ -267,7 +266,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 			else
 				memset(bl, 0, size*3*sizeof(unsigned int));
 
-			if (surf->dlightframe == r_framecount && r_dlightmap.integer)
+			if (surf->dlightframe == r_framecount)
 			{
 				surf->cached_dlight = R_IntAddDynamicLights(&ent->inversematrix, surf);
 				if (surf->cached_dlight)
@@ -289,7 +288,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 		out = templight;
 		// deal with lightmap brightness scale
 		shift = 7 + r_lightmapscalebit + 8;
-		if (ent->model->lightmaprgba)
+		if (ent->model->brushq1.lightmaprgba)
 		{
 			stride = (surf->lightmaptexturestride - smax) * 4;
 			for (i = 0;i < tmax;i++, out += stride)
@@ -336,7 +335,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 
 	// set to full bright if no light data
 		bl = floatblocklights;
-		if ((ent->effects & EF_FULLBRIGHT) || !ent->model->lightdata)
+		if ((ent->effects & EF_FULLBRIGHT) || !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
@@ -350,7 +349,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 		else
 			memset(bl, 0, size*3*sizeof(float));
 
-		if (surf->dlightframe == r_framecount && r_dlightmap.integer)
+		if (surf->dlightframe == r_framecount)
 		{
 			surf->cached_dlight = R_FloatAddDynamicLights(&ent->inversematrix, surf);
 			if (surf->cached_dlight)
@@ -371,7 +370,7 @@ static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
 		out = templight;
 		// deal with lightmap brightness scale
 		scale = 1.0f / (1 << (7 + r_lightmapscalebit + 8));
-		if (ent->model->lightmaprgba)
+		if (ent->model->brushq1.lightmaprgba)
 		{
 			stride = (surf->lightmaptexturestride - smax) * 4;
 			for (i = 0;i < tmax;i++, out += stride)
@@ -444,7 +443,7 @@ loc0:
 		impact[2] = origin[2] - node->plane->normal[2] * ndist;
 	}
 
-	for (surf = model->surfaces + node->firstsurface, endsurf = surf + node->numsurfaces;surf < endsurf;surf++)
+	for (surf = model->brushq1.surfaces + node->firstsurface, endsurf = surf + node->numsurfaces;surf < endsurf;surf++)
 	{
 		if (surf->stainsamples)
 		{
@@ -532,7 +531,7 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int
 	entity_render_t *ent;
 	model_t *model;
 	vec3_t org;
-	if (cl.worldmodel == NULL)
+	if (cl.worldmodel == NULL || !cl.worldmodel->brushq1.nodes)
 		return;
 	fcolor[0] = cr1;
 	fcolor[1] = cg1;
@@ -543,7 +542,7 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int
 	fcolor[6] = cb2 - cb1;
 	fcolor[7] = (ca2 - ca1) * (1.0f / 64.0f);
 
-	R_StainNode(cl.worldmodel->nodes + cl.worldmodel->hulls[0].firstclipnode, cl.worldmodel, origin, radius, fcolor);
+	R_StainNode(cl.worldmodel->brushq1.nodes + cl.worldmodel->brushq1.hulls[0].firstclipnode, cl.worldmodel, origin, radius, fcolor);
 
 	// look for embedded bmodels
 	for (n = 0;n < cl_num_brushmodel_entities;n++)
@@ -553,10 +552,10 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int
 		if (model && model->name[0] == '*')
 		{
 			Mod_CheckLoaded(model);
-			if (model->type == mod_brush)
+			if (model->brushq1.nodes)
 			{
 				Matrix4x4_Transform(&ent->inversematrix, origin, org);
-				R_StainNode(model->nodes + model->hulls[0].firstclipnode, model, org, radius, fcolor);
+				R_StainNode(model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode, model, org, radius, fcolor);
 			}
 		}
 	}
@@ -701,35 +700,13 @@ static int RSurf_LightSeparate_Vertex3f_Color4f(const matrix4x4_t *matrix, const
 	return lit;
 }
 
-// note: this untransforms lights to do the checking
-static int RSurf_LightCheck(const matrix4x4_t *matrix, const int *dlightbits, const surfmesh_t *mesh)
-{
-	int i, l;
-	const rdlight_t *rd;
-	vec3_t lightorigin;
-	const float *v;
-	for (l = 0;l < r_numdlights;l++)
-	{
-		if (dlightbits[l >> 5] & (1 << (l & 31)))
-		{
-			rd = &r_dlight[l];
-			Matrix4x4_Transform(matrix, rd->origin, lightorigin);
-			for (i = 0, v = mesh->vertex3f;i < mesh->numverts;i++, v += 3)
-				if (VectorDistance2(v, lightorigin) < rd->cullradius2)
-					return true;
-		}
-	}
-	return false;
-}
-
 static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 
 	// LordHavoc: HalfLife maps have freaky skypolys...
-	if (ent->model->ishlbsp)
+	if (ent->model->brush.ishlbsp)
 		return;
 
 	if (skyrendernow)
@@ -741,7 +718,7 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
 
 	R_Mesh_Matrix(&ent->matrix);
 
-	GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, 1);
+	GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], 1);
 	if (skyrendermasked)
 	{
 		// depth-only (masking)
@@ -765,11 +742,8 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 	qglColorMask(1,1,1,1);
@@ -778,16 +752,22 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
 static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 {
 	const entity_render_t *ent = calldata1;
-	const msurface_t *surf = ent->model->surfaces + calldata2;
-	float f, colorscale;
-	const surfmesh_t *mesh;
+	const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
 	rmeshstate_t m;
 	float alpha;
 	float modelorg[3];
 	texture_t *texture;
 	matrix4x4_t tempmatrix;
+	float	args[4] = {0.05f,0,0,0.04f};
 
-	if (r_waterscroll.value)
+	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);
@@ -815,31 +795,46 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		GL_DepthMask(true);
 	}
-	m.tex[0] = R_GetTexture(texture->skin.base);
-	colorscale = r_colorscale;
-	if (gl_combine.integer)
+	if (gl_textureshader && r_watershader.value && !fogenabled)
 	{
-		m.texrgbscale[0] = 4;
-		colorscale *= 0.25f;
+		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);
-	GL_ColorPointer(varray_color4f);
-	for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+	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)
 	{
-		GL_VertexPointer(mesh->vertex3f);
-		m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-		R_Mesh_State_Texture(&m);
-		f = surf->flags & SURF_DRAWFULLBRIGHT ? 1.0f : ((surf->flags & SURF_LIGHTMAP) ? 0 : 0.5f);
-		R_FillColors(varray_color4f, mesh->numverts, f, f, f, alpha);
-		if (!(surf->flags & SURF_DRAWFULLBRIGHT || ent->effects & EF_FULLBRIGHT))
-		{
-			if (surf->dlightframe == r_framecount)
-				RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, 1);
-			if (surf->flags & SURF_LIGHTMAP)
-				RSurf_AddLightmapToVertexColors_Color4f(mesh->lightmapoffsets, varray_color4f, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles);
-		}
-		RSurf_FogColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg);
-		R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
+		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);
+
+	if (gl_textureshader && r_watershader.value && !fogenabled)
+	{
+		qglDisable (GL_TEXTURE_SHADER_NV);
+		GL_ActiveTexture (0);
 	}
 
 	if (fogenabled)
@@ -849,21 +844,19 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 		GL_DepthMask(false);
 		GL_DepthTest(true);
 		m.tex[0] = R_GetTexture(texture->skin.fog);
-		for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-		{
-			GL_VertexPointer(mesh->vertex3f);
-			m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-			GL_ColorPointer(varray_color4f);
-			R_Mesh_State_Texture(&m);
-			RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], alpha, r_colorscale, mesh->numverts, modelorg);
-			R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-		}
+		GL_VertexPointer(surf->mesh.data_vertex3f);
+		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);
+		R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 	}
 
-	if (r_waterscroll.value)
+	if ((gl_textureshader && r_watershader.value && !fogenabled) || r_waterscroll.value)
 	{
 		Matrix4x4_CreateIdentity(&tempmatrix);
 		R_Mesh_TextureMatrix(0, &tempmatrix);
+		R_Mesh_TextureMatrix(1, &tempmatrix);
 	}
 }
 
@@ -879,20 +872,19 @@ static void RSurfShader_Water(const entity_render_t *ent, const texture_t *textu
 			if (surf->visframe == r_framecount)
 			{
 				Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
-				R_MeshQueue_AddTransparent(center, RSurfShader_Water_Callback, ent, surf - ent->model->surfaces);
+				R_MeshQueue_AddTransparent(center, RSurfShader_Water_Callback, ent, surf - ent->model->brushq1.surfaces);
 			}
 		}
 	}
 	else
 		for (chain = surfchain;(surf = *chain) != NULL;chain++)
 			if (surf->visframe == r_framecount)
-				RSurfShader_Water_Callback(ent, surf - ent->model->surfaces);
+				RSurfShader_Water_Callback(ent, surf - ent->model->brushq1.surfaces);
 }
 
 static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
 	float base, colorscale;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	float modelorg[3];
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -913,7 +905,7 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m
 		GL_DepthMask(true);
 	}
 	m.tex[0] = R_GetTexture(texture->skin.base);
-	colorscale = r_colorscale;
+	colorscale = 1;
 	if (gl_combine.integer)
 	{
 		m.texrgbscale[0] = 4;
@@ -922,27 +914,24 @@ 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);
-	for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+
+	GL_VertexPointer(surf->mesh.data_vertex3f);
+	m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+	R_Mesh_State_Texture(&m);
+	R_FillColors(varray_color4f, surf->mesh.num_vertices, base, base, base, currentalpha);
+	if (!(ent->effects & EF_FULLBRIGHT))
 	{
-		GL_VertexPointer(mesh->vertex3f);
-		m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-		R_Mesh_State_Texture(&m);
-		R_FillColors(varray_color4f, mesh->numverts, base, base, base, currentalpha);
-		if (!(ent->effects & EF_FULLBRIGHT))
-		{
-			if (surf->dlightframe == r_framecount)
-				RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, 1);
-			if (surf->flags & SURF_LIGHTMAP)
-				RSurf_AddLightmapToVertexColors_Color4f(mesh->lightmapoffsets, varray_color4f, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles);
-		}
-		RSurf_FogColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg);
-		R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
+		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)
+			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);
+	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	float modelorg[3];
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -952,20 +941,17 @@ static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurfac
 	GL_DepthTest(true);
 	m.tex[0] = R_GetTexture(texture->skin.glow);
 	GL_ColorPointer(varray_color4f);
-	for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-	{
-		GL_VertexPointer(mesh->vertex3f);
-		if (m.tex[0])
-			m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-		R_Mesh_State_Texture(&m);
-		RSurf_FoggedColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, 1, 1, 1, currentalpha, r_colorscale, mesh->numverts, modelorg);
-		R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-	}
+
+	GL_VertexPointer(surf->mesh.data_vertex3f);
+	if (m.tex[0])
+		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+	R_Mesh_State_Texture(&m);
+	RSurf_FoggedColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, 1, 1, currentalpha, 1, surf->mesh.num_vertices, modelorg);
+	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	float modelorg[3];
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -975,21 +961,18 @@ static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface
 	GL_DepthTest(true);
 	m.tex[0] = R_GetTexture(texture->skin.fog);
 	GL_ColorPointer(varray_color4f);
-	for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-	{
-		GL_VertexPointer(mesh->vertex3f);
-		if (m.tex[0])
-			m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-		R_Mesh_State_Texture(&m);
-		RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, r_colorscale, mesh->numverts, modelorg);
-		R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-	}
+
+	GL_VertexPointer(surf->mesh.data_vertex3f);
+	if (m.tex[0])
+		m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+	R_Mesh_State_Texture(&m);
+	RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, 1, surf->mesh.num_vertices, modelorg);
+	R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	int lightmaptexturenum;
 	float cl;
@@ -1003,7 +986,7 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render
 	m.texrgbscale[0] = 1;
 	m.texrgbscale[1] = 4;
 	m.texrgbscale[2] = 2;
-	cl = (float) (1 << r_lightmapscalebit) * r_colorscale;
+	cl = (float) (1 << r_lightmapscalebit);
 	GL_Color(cl, cl, cl, 1);
 
 	while((surf = *surfchain++) != NULL)
@@ -1016,15 +999,12 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render
 				m.tex[1] = lightmaptexturenum;
 			//	R_Mesh_State_Texture(&m);
 			//}
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				m.pointer_texcoord[1] = mesh->texcoordlightmap2f;
-				m.pointer_texcoord[2] = mesh->texcoorddetail2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(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_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1032,7 +1012,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render
 static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	int lightmaptexturenum;
 	memset(&m, 0, sizeof(m));
@@ -1043,7 +1022,7 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent
 	m.tex[1] = R_GetTexture((**surfchain).lightmaptexture);
 	if (gl_combine.integer)
 		m.texrgbscale[1] = 4;
-	GL_Color(r_colorscale, r_colorscale, r_colorscale, 1);
+	GL_Color(1, 1, 1, 1);
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
@@ -1054,14 +1033,11 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent
 				m.tex[1] = lightmaptexturenum;
 			//	R_Mesh_State_Texture(&m);
 			//}
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				m.pointer_texcoord[1] = mesh->texcoordlightmap2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(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_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1069,7 +1045,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent
 static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
 	GL_DepthMask(true);
@@ -1081,13 +1056,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent,
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+			R_Mesh_State_Texture(&m);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1095,7 +1067,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent,
 static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	int lightmaptexturenum;
 	memset(&m, 0, sizeof(m));
@@ -1105,7 +1076,7 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 	m.tex[0] = R_GetTexture((**surfchain).lightmaptexture);
 	if (gl_combine.integer)
 		m.texrgbscale[0] = 4;
-	GL_Color(r_colorscale, r_colorscale, r_colorscale, 1);
+	GL_Color(1, 1, 1, 1);
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
@@ -1116,52 +1087,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 				m.tex[0] = lightmaptexturenum;
 			//	R_Mesh_State_Texture(&m);
 			//}
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordlightmap2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
-		}
-	}
-}
-
-static void RSurfShader_OpaqueWall_Pass_Light(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
-{
-	const msurface_t *surf;
-	const surfmesh_t *mesh;
-	float colorscale;
-	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);
-	colorscale = r_colorscale;
-	if (gl_combine.integer)
-	{
-		m.texrgbscale[0] = 4;
-		colorscale *= 0.25f;
-	}
-	GL_ColorPointer(varray_color4f);
-	while((surf = *surfchain++) != NULL)
-	{
-		if (surf->visframe == r_framecount && surf->dlightframe == r_framecount)
-		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				if (RSurf_LightCheck(&ent->inversematrix, surf->dlightbits, mesh))
-				{
-					GL_VertexPointer(mesh->vertex3f);
-					m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-					R_FillColors(varray_color4f, mesh->numverts, 0, 0, 0, 1);
-					R_Mesh_State_Texture(&m);
-					RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, colorscale);
-					R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-				}
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
+			R_Mesh_State_Texture(&m);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1169,7 +1098,6 @@ static void RSurfShader_OpaqueWall_Pass_Light(const entity_render_t *ent, const
 static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	float modelorg[3];
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -1182,15 +1110,12 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				if (m.tex[0])
-					m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				R_Mesh_State_Texture(&m);
-				RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, r_colorscale, mesh->numverts, modelorg);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			if (m.tex[0])
+				m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+			R_Mesh_State_Texture(&m);
+			RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, 1, surf->mesh.num_vertices, modelorg);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1198,7 +1123,6 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te
 static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
 	GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
@@ -1210,13 +1134,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoorddetail2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_texcoord[0] = surf->mesh.data_texcoorddetail2f;
+			R_Mesh_State_Texture(&m);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1224,25 +1145,21 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c
 static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	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.glow);
-	GL_Color(r_colorscale, r_colorscale, r_colorscale, 1);
+	GL_Color(1, 1, 1, 1);
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+			R_Mesh_State_Texture(&m);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1250,27 +1167,23 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t
 static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
 	const msurface_t *surf;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	memset(&m, 0, sizeof(m));
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
 	GL_DepthMask(true);
 	m.tex[0] = R_GetTexture(texture->skin.glow);
 	if (m.tex[0])
-		GL_Color(r_colorscale, r_colorscale, r_colorscale, 1);
+		GL_Color(1, 1, 1, 1);
 	else
 		GL_Color(0, 0, 0, 1);
 	while((surf = *surfchain++) != NULL)
 	{
 		if (surf->visframe == r_framecount)
 		{
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-			{
-				GL_VertexPointer(mesh->vertex3f);
-				m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-				R_Mesh_State_Texture(&m);
-				R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-			}
+			GL_VertexPointer(surf->mesh.data_vertex3f);
+			m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+			R_Mesh_State_Texture(&m);
+			R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 		}
 	}
 }
@@ -1278,7 +1191,7 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, c
 static void RSurfShader_Wall_Vertex_Callback(const void *calldata1, int calldata2)
 {
 	const entity_render_t *ent = calldata1;
-	const msurface_t *surf = ent->model->surfaces + calldata2;
+	const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
 	int rendertype;
 	float currentalpha;
 	texture_t *texture;
@@ -1289,8 +1202,6 @@ static void RSurfShader_Wall_Vertex_Callback(const void *calldata1, int calldata
 		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 (texture->flags & SURF_WATERALPHA)
-		currentalpha *= r_wateralpha.value;
 	if (ent->effects & EF_ADDITIVE)
 		rendertype = SURFRENDER_ADD;
 	else if (currentalpha < 1 || texture->skin.fog != NULL)
@@ -1318,7 +1229,7 @@ static void RSurfShader_Wall_Lightmap(const entity_render_t *ent, const texture_
 			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->surfaces);
+				R_MeshQueue_AddTransparent(center, RSurfShader_Wall_Vertex_Callback, ent, surf - ent->model->brushq1.surfaces);
 			}
 		}
 	}
@@ -1329,34 +1240,16 @@ static void RSurfShader_Wall_Lightmap(const entity_render_t *ent, const texture_
 		if (fogenabled)
 			RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
 	}
-	else if (r_vertexsurfaces.integer)
-	{
-		// opaque vertex shaded from lightmap
-		for (chain = surfchain;(surf = *chain) != NULL;chain++)
-			if (surf->visframe == r_framecount)
-				RSurfShader_Wall_Pass_BaseVertex(ent, surf, texture, texture->rendertype, texture->currentalpha);
-		if (texture->skin.glow)
-			for (chain = surfchain;(surf = *chain) != NULL;chain++)
-				if (surf->visframe == r_framecount)
-					RSurfShader_Wall_Pass_Glow(ent, surf, texture, texture->rendertype, texture->currentalpha);
-		if (fogenabled)
-			for (chain = surfchain;(surf = *chain) != NULL;chain++)
-				if (surf->visframe == r_framecount)
-					RSurfShader_Wall_Pass_Fog(ent, surf, texture, texture->rendertype, texture->currentalpha);
-	}
 	else
 	{
 		// opaque lightmapped
-		if (r_textureunits.integer >= 2)
+		if (r_textureunits.integer >= 3 && gl_combine.integer && r_detailtextures.integer)
+			RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(ent, texture, surfchain);
+		else if (r_textureunits.integer >= 2)
 		{
-			if (r_textureunits.integer >= 3 && gl_combine.integer && r_detailtextures.integer)
-				RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(ent, texture, surfchain);
-			else
-			{
-				RSurfShader_OpaqueWall_Pass_BaseDoubleTex(ent, texture, surfchain);
-				if (r_detailtextures.integer)
-					RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
-			}
+			RSurfShader_OpaqueWall_Pass_BaseDoubleTex(ent, texture, surfchain);
+			if (r_detailtextures.integer)
+				RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
 		}
 		else
 		{
@@ -1365,8 +1258,6 @@ static void RSurfShader_Wall_Lightmap(const entity_render_t *ent, const texture_
 			if (r_detailtextures.integer)
 				RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
 		}
-		if (!r_dlightmap.integer && !(ent->effects & EF_FULLBRIGHT))
-			RSurfShader_OpaqueWall_Pass_Light(ent, texture, surfchain);
 		if (texture->skin.glow)
 			RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
 		if (fogenabled)
@@ -1396,9 +1287,9 @@ void R_UpdateTextureInfo(entity_render_t *ent)
 
 	alttextures = ent->frame != 0;
 	texframe = (int)(cl.time * 5.0f);
-	for (i = 0;i < ent->model->numtextures;i++)
+	for (i = 0;i < ent->model->brushq1.numtextures;i++)
 	{
-		t = ent->model->textures + i;
+		t = ent->model->brushq1.textures + i;
 		t->currentalpha = ent->alpha;
 		if (t->flags & SURF_WATERALPHA)
 			t->currentalpha *= r_wateralpha.value;
@@ -1427,30 +1318,30 @@ void R_PrepareSurfaces(entity_render_t *ent)
 
 	model = ent->model;
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
-	numsurfaces = model->nummodelsurfaces;
-	surfaces = model->surfaces + model->firstmodelsurface;
-	surfacevisframes = model->surfacevisframes + model->firstmodelsurface;
+	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->light_ambient != r_ambient.value || model->light_scalebit != r_lightmapscalebit)
+	if (model->brushq1.light_ambient != r_ambient.value || model->brushq1.light_scalebit != r_lightmapscalebit)
 	{
-		model->light_ambient = r_ambient.value;
-		model->light_scalebit = r_lightmapscalebit;
-		for (i = 0;i < model->nummodelsurfaces;i++)
-			model->surfaces[i + model->firstmodelsurface].cached_dlight = true;
+		model->brushq1.light_ambient = r_ambient.value;
+		model->brushq1.light_scalebit = r_lightmapscalebit;
+		for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
+			model->brushq1.surfaces[i + model->brushq1.firstmodelsurface].cached_dlight = true;
 	}
 	else
 	{
-		for (i = 0;i < model->light_styles;i++)
+		for (i = 0;i < model->brushq1.light_styles;i++)
 		{
-			if (model->light_stylevalue[i] != d_lightstylevalue[model->light_style[i]])
+			if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
 			{
-				model->light_stylevalue[i] = d_lightstylevalue[model->light_style[i]];
-				for (surfchain = model->light_styleupdatechains[i];*surfchain;surfchain++)
+				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;
 			}
 		}
@@ -1477,7 +1368,7 @@ void R_PrepareSurfaces(entity_render_t *ent)
 			{
 				c_faces++;
 				surf->visframe = r_framecount;
-				if (surf->cached_dlight && surf->lightmaptexture != NULL && !r_vertexsurfaces.integer)
+				if (surf->cached_dlight && surf->lightmaptexture != NULL)
 					R_BuildLightMap(ent, surf);
 			}
 		}
@@ -1491,7 +1382,7 @@ void R_DrawSurfaces(entity_render_t *ent, int type, msurface_t ***chains)
 	if (ent->model == NULL)
 		return;
 	R_Mesh_Matrix(&ent->matrix);
-	for (i = 0, t = ent->model->textures;i < ent->model->numtextures;i++, t++)
+	for (i = 0, t = ent->model->brushq1.textures;i < ent->model->brushq1.numtextures;i++, t++)
 		if (t->shader->shaderfunc[type] && t->currentframe && chains[i] != NULL)
 			t->shader->shaderfunc[type](ent, t->currentframe, chains[i]);
 }
@@ -1502,7 +1393,7 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
 	float *v;
 	rmeshstate_t m;
 	const entity_render_t *ent = calldata1;
-	const mportal_t *portal = ent->model->portals + calldata2;
+	const mportal_t *portal = ent->model->brushq1.portals + calldata2;
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	GL_DepthMask(false);
 	GL_DepthTest(true);
@@ -1512,12 +1403,12 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
 	memset(&m, 0, sizeof(m));
 	R_Mesh_State_Texture(&m);
 
-	i = portal - ent->model->portals;
-	GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_colorscale,
-			 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_colorscale,
-			 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_colorscale,
+	i = portal - ent->model->brushq1.portals;
+	GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f),
+			 ((i & 0x0038) >> 3) * (1.0f / 7.0f),
+			 ((i & 0x01C0) >> 6) * (1.0f / 7.0f),
 			 0.125f);
-	if (PlaneDiff(r_origin, (&portal->plane)) > 0)
+	if (PlaneDiff(r_origin, (&portal->plane)) < 0)
 	{
 		for (i = portal->numpoints - 1, v = varray_vertex3f;i >= 0;i--, v += 3)
 			VectorCopy(portal->points[i].position, v);
@@ -1528,6 +1419,7 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
 	R_Mesh_Draw(portal->numpoints, portal->numpoints - 2, polygonelements);
 }
 
+// LordHavoc: this is just a nice debugging tool, very slow
 static void R_DrawPortals(entity_render_t *ent)
 {
 	int i;
@@ -1535,9 +1427,9 @@ static void R_DrawPortals(entity_render_t *ent)
 	float temp[3], center[3], f;
 	if (ent->model == NULL)
 		return;
-	for (portal = ent->model->portals, endportal = portal + ent->model->numportals;portal < endportal;portal++)
+	for (portal = ent->model->brushq1.portals, endportal = portal + ent->model->brushq1.numportals;portal < endportal;portal++)
 	{
-		if ((portal->here->pvsframe == ent->model->pvsframecount || portal->past->pvsframe == ent->model->pvsframecount) && portal->numpoints <= POLYGONELEMENTS_MAXPOINTS)
+		if (portal->numpoints <= POLYGONELEMENTS_MAXPOINTS)
 		{
 			VectorClear(temp);
 			for (i = 0;i < portal->numpoints;i++)
@@ -1545,7 +1437,7 @@ static void R_DrawPortals(entity_render_t *ent)
 			f = ixtable[portal->numpoints];
 			VectorScale(temp, f, temp);
 			Matrix4x4_Transform(&ent->matrix, temp, center);
-			R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, ent, portal - ent->model->portals);
+			R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, ent, portal - ent->model->brushq1.portals);
 		}
 	}
 }
@@ -1567,10 +1459,10 @@ void R_PrepareBrushModel(entity_render_t *ent)
 #if WORLDNODECULLBACKFACES
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
 #endif
-	numsurfaces = model->nummodelsurfaces;
-	surf = model->surfaces + model->firstmodelsurface;
-	surfacevisframes = model->surfacevisframes + model->firstmodelsurface;
-	surfacepvsframes = model->surfacepvsframes + model->firstmodelsurface;
+	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;
 	for (i = 0;i < numsurfaces;i++, surf++)
 	{
 #if WORLDNODECULLBACKFACES
@@ -1602,11 +1494,11 @@ void R_SurfaceWorldNode (entity_render_t *ent)
 	model = ent->model;
 	if (model == NULL)
 		return;
-	surfacevisframes = model->surfacevisframes + model->firstmodelsurface;
-	surfacepvsframes = model->surfacepvsframes + model->firstmodelsurface;
+	surfacevisframes = model->brushq1.surfacevisframes + model->brushq1.firstmodelsurface;
+	surfacepvsframes = model->brushq1.surfacepvsframes + model->brushq1.firstmodelsurface;
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
 
-	for (leaf = model->pvsleafchain;leaf;leaf = leaf->pvschain)
+	for (leaf = model->brushq1.pvsleafchain;leaf;leaf = leaf->pvschain)
 	{
 		if (!R_CullBox (leaf->mins, leaf->maxs))
 		{
@@ -1615,10 +1507,10 @@ void R_SurfaceWorldNode (entity_render_t *ent)
 		}
 	}
 
-	for (i = 0;i < model->pvssurflistlength;i++)
+	for (i = 0;i < model->brushq1.pvssurflistlength;i++)
 	{
-		surfnum = model->pvssurflist[i];
-		surf = model->surfaces + surfnum;
+		surfnum = model->brushq1.pvssurflist[i];
+		surf = model->brushq1.surfaces + surfnum;
 #if WORLDNODECULLBACKFACES
 		if (PlaneDist(modelorg, surf->plane) < surf->plane->dist)
 		{
@@ -1639,7 +1531,7 @@ void R_SurfaceWorldNode (entity_render_t *ent)
 
 static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
 {
-	int c, leafstackpos, *mark, *surfacevisframes;
+	int c, leafstackpos, *mark, *surfacevisframes, bitnum;
 #if WORLDNODECULLBACKFACES
 	int n;
 	msurface_t *surf;
@@ -1654,8 +1546,8 @@ static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
 	// follows portals leading outward from viewleaf, does not venture
 	// offscreen or into leafs that are not visible, faster than Quake's
 	// RecursiveWorldNode
-	surfaces = ent->model->surfaces;
-	surfacevisframes = ent->model->surfacevisframes;
+	surfaces = ent->model->brushq1.surfaces;
+	surfacevisframes = ent->model->brushq1.surfacevisframes;
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
 	viewleaf->worldnodeframe = r_framecount;
 	leafstack[0] = viewleaf;
@@ -1703,7 +1595,8 @@ static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
 				{
 					leaf->worldnodeframe = r_framecount;
 					// FIXME: R_CullBox is absolute, should be done relative
-					if (leaf->pvsframe == ent->model->pvsframecount && !R_CullBox(leaf->mins, leaf->maxs))
+					bitnum = (leaf - ent->model->brushq1.leafs) - 1;
+					if ((r_pvsbits[bitnum >> 3] & (1 << (bitnum & 7))) && !R_CullBox(leaf->mins, leaf->maxs))
 						leafstack[leafstackpos++] = leaf;
 				}
 			}
@@ -1713,58 +1606,46 @@ static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
 
 void R_PVSUpdate (entity_render_t *ent, mleaf_t *viewleaf)
 {
-	int i, j, l, c, bits, *surfacepvsframes, *mark;
+	int j, c, *surfacepvsframes, *mark;
 	mleaf_t *leaf;
-	qbyte *vis;
 	model_t *model;
 
 	model = ent->model;
-	if (model && (model->pvsviewleaf != viewleaf || model->pvsviewleafnovis != r_novis.integer))
+	if (model && (model->brushq1.pvsviewleaf != viewleaf || model->brushq1.pvsviewleafnovis != r_novis.integer))
 	{
-		model->pvsframecount++;
-		model->pvsviewleaf = viewleaf;
-		model->pvsviewleafnovis = r_novis.integer;
-		model->pvsleafchain = NULL;
-		model->pvssurflistlength = 0;
+		model->brushq1.pvsframecount++;
+		model->brushq1.pvsviewleaf = viewleaf;
+		model->brushq1.pvsviewleafnovis = r_novis.integer;
+		model->brushq1.pvsleafchain = NULL;
+		model->brushq1.pvssurflistlength = 0;
 		if (viewleaf)
 		{
-			surfacepvsframes = model->surfacepvsframes;
-			vis = model->LeafPVS(model, viewleaf);
-			for (j = 0;j < model->numleafs;j += 8)
+			surfacepvsframes = model->brushq1.surfacepvsframes;
+			for (j = 0;j < model->brushq1.visleafs;j++)
 			{
-				bits = *vis++;
-				if (bits)
+				if (r_pvsbits[j >> 3] & (1 << (j & 7)))
 				{
-					l = model->numleafs - j;
-					if (l > 8)
-						l = 8;
-					for (i = 0;i < l;i++)
-					{
-						if (bits & (1 << i))
-						{
-							leaf = &model->leafs[j + i + 1];
-							leaf->pvschain = model->pvsleafchain;
-							model->pvsleafchain = leaf;
-							leaf->pvsframe = model->pvsframecount;
-							// mark surfaces bounding this leaf as visible
-							for (c = leaf->nummarksurfaces, mark = leaf->firstmarksurface;c;c--, mark++)
-								surfacepvsframes[*mark] = model->pvsframecount;
-						}
-					}
+					leaf = model->brushq1.leafs + j + 1;
+					leaf->pvsframe = model->brushq1.pvsframecount;
+					leaf->pvschain = model->brushq1.pvsleafchain;
+					model->brushq1.pvsleafchain = leaf;
+					// mark surfaces bounding this leaf as visible
+					for (c = leaf->nummarksurfaces, mark = leaf->firstmarksurface;c;c--, mark++)
+						surfacepvsframes[*mark] = model->brushq1.pvsframecount;
 				}
 			}
-			model->BuildPVSTextureChains(model);
+			model->brushq1.BuildPVSTextureChains(model);
 		}
 	}
 }
 
-void R_WorldVisibility (entity_render_t *ent)
+void R_WorldVisibility(entity_render_t *ent)
 {
 	vec3_t modelorg;
 	mleaf_t *viewleaf;
 
 	Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
-	viewleaf = ent->model ? ent->model->PointInLeaf(ent->model, modelorg) : NULL;
+	viewleaf = (ent->model && ent->model->brushq1.PointInLeaf) ? ent->model->brushq1.PointInLeaf(ent->model, modelorg) : NULL;
 	R_PVSUpdate(ent, viewleaf);
 
 	if (!viewleaf)
@@ -1776,34 +1657,39 @@ void R_WorldVisibility (entity_render_t *ent)
 		R_PortalWorldNode (ent, viewleaf);
 }
 
-void R_DrawWorld (entity_render_t *ent)
+void R_DrawWorld(entity_render_t *ent)
 {
 	if (ent->model == NULL)
 		return;
-	R_PrepareSurfaces(ent);
-	R_DrawSurfaces(ent, SHADERSTAGE_SKY, ent->model->pvstexturechains);
-	R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->pvstexturechains);
-	if (r_drawportals.integer)
-		R_DrawPortals(ent);
+	if (!ent->model->brushq1.numleafs && ent->model->Draw)
+		ent->model->Draw(ent);
+	else
+	{
+		R_PrepareSurfaces(ent);
+		R_DrawSurfaces(ent, SHADERSTAGE_SKY, ent->model->brushq1.pvstexturechains);
+		R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->brushq1.pvstexturechains);
+		if (r_drawportals.integer)
+			R_DrawPortals(ent);
+	}
 }
 
-void R_Model_Brush_DrawSky (entity_render_t *ent)
+void R_Model_Brush_DrawSky(entity_render_t *ent)
 {
 	if (ent->model == NULL)
 		return;
 	if (ent != &cl_entities[0].render)
 		R_PrepareBrushModel(ent);
-	R_DrawSurfaces(ent, SHADERSTAGE_SKY, ent->model->pvstexturechains);
+	R_DrawSurfaces(ent, SHADERSTAGE_SKY, ent->model->brushq1.pvstexturechains);
 }
 
-void R_Model_Brush_Draw (entity_render_t *ent)
+void R_Model_Brush_Draw(entity_render_t *ent)
 {
 	if (ent->model == NULL)
 		return;
 	c_bmodels++;
 	if (ent != &cl_entities[0].render)
 		R_PrepareBrushModel(ent);
-	R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->pvstexturechains);
+	R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->brushq1.pvstexturechains);
 }
 
 void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
@@ -1811,14 +1697,13 @@ void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelighto
 	int i;
 	msurface_t *surf;
 	float projectdistance, f, temp[3], lightradius2;
-	surfmesh_t *mesh;
 	if (ent->model == NULL)
 		return;
 	R_Mesh_Matrix(&ent->matrix);
 	lightradius2 = lightradius * lightradius;
 	R_UpdateTextureInfo(ent);
 	projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
-	for (i = 0, surf = ent->model->surfaces + ent->model->firstmodelsurface;i < ent->model->nummodelsurfaces;i++, surf++)
+	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)
 		{
@@ -1832,8 +1717,7 @@ void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelighto
 				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)
-					for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-						R_Shadow_Volume(mesh->numverts, mesh->numtriangles, mesh->vertex3f, mesh->element3i, mesh->neighbor3i, relativelightorigin, lightradius, projectdistance);
+					R_Shadow_Volume(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_vertex3f, surf->mesh.data_element3i, surf->mesh.data_neighbor3i, relativelightorigin, lightradius, projectdistance);
 			}
 		}
 	}
@@ -1844,7 +1728,6 @@ void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relative
 	int surfnum;
 	msurface_t *surf;
 	texture_t *t;
-	surfmesh_t *mesh;
 	if (ent->model == NULL)
 		return;
 	R_Mesh_Matrix(&ent->matrix);
@@ -1857,11 +1740,8 @@ void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relative
 			t = surf->texinfo->texture->currentframe;
 			if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
 			{
-				for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-				{
-					R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
-					R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
-				}
+				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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
+				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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
 			}
 		}
 	}
@@ -1873,7 +1753,6 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 	msurface_t *surf;
 	texture_t *t;
 	float f, lightmins[3], lightmaxs[3];
-	surfmesh_t *mesh;
 	if (ent->model == NULL)
 		return;
 	R_Mesh_Matrix(&ent->matrix);
@@ -1884,7 +1763,7 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 	lightmaxs[1] = relativelightorigin[1] + lightradius;
 	lightmaxs[2] = relativelightorigin[2] + lightradius;
 	R_UpdateTextureInfo(ent);
-	for (surfnum = 0, surf = ent->model->surfaces + ent->model->firstmodelsurface;surfnum < ent->model->nummodelsurfaces;surfnum++, surf++)
+	for (surfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;surfnum < ent->model->brushq1.nummodelsurfaces;surfnum++, surf++)
 	{
 		if ((ent != &cl_entities[0].render || surf->visframe == r_framecount) && BoxesOverlap(surf->poly_mins, surf->poly_maxs, lightmins, lightmaxs))
 		{
@@ -1896,17 +1775,229 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 				t = surf->texinfo->texture->currentframe;
 				if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
 				{
-					for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-					{
-						R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
-						R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
-					}
+					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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
+					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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
 				}
 			}
 		}
 	}
 }
 
+void R_DrawCollisionBrush(colbrushf_t *brush)
+{
+	int i;
+	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);
+	R_Mesh_Draw(brush->numpoints, brush->numtriangles, brush->elements);
+}
+
+void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
+{
+	rmeshstate_t m;
+	if (!face->num_triangles)
+		return;
+	if (face->texture->renderflags)
+	{
+		if (face->texture->renderflags & Q3MTEXTURERENDERFLAGS_SKY)
+		{
+			if (skyrendernow)
+			{
+				skyrendernow = false;
+				if (skyrendermasked)
+					R_Sky();
+			}
+
+			R_Mesh_Matrix(&ent->matrix);
+
+			GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], 1);
+			if (skyrendermasked)
+			{
+				// depth-only (masking)
+				qglColorMask(0,0,0,0);
+				// just to make sure that braindead drivers don't draw anything
+				// despite that colormask...
+				GL_BlendFunc(GL_ZERO, GL_ONE);
+			}
+			else
+			{
+				// fog sky
+				GL_BlendFunc(GL_ONE, GL_ZERO);
+			}
+			GL_DepthMask(true);
+			GL_DepthTest(true);
+
+			memset(&m, 0, sizeof(m));
+			R_Mesh_State_Texture(&m);
+
+			GL_VertexPointer(face->data_vertex3f);
+			R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+			qglColorMask(1,1,1,1);
+			return;
+		}
+		if (face->texture->renderflags & Q3MTEXTURERENDERFLAGS_NODRAW)
+			return;
+	}
+	R_Mesh_Matrix(&ent->matrix);
+	face->visframe = r_framecount;
+	memset(&m, 0, sizeof(m));
+	GL_BlendFunc(GL_ONE, GL_ZERO);
+	GL_DepthMask(true);
+	GL_DepthTest(true);
+	m.tex[0] = R_GetTexture(face->texture->skin.base);
+	m.pointer_texcoord[0] = face->data_texcoordtexture2f;
+	if (face->lightmaptexture)
+	{
+		m.tex[1] = R_GetTexture(face->lightmaptexture);
+		m.pointer_texcoord[1] = face->data_texcoordlightmap2f;
+		m.texrgbscale[1] = 2;
+		GL_Color(1, 1, 1, 1);
+	}
+	else
+	{
+		m.texrgbscale[0] = 2;
+		GL_ColorPointer(face->data_color4f);
+	}
+	R_Mesh_State_Texture(&m);
+	GL_VertexPointer(face->data_vertex3f);
+	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
+}
+
+/*
+void R_Q3BSP_DrawSky(entity_render_t *ent)
+{
+}
+*/
+
+void R_Q3BSP_RecursiveWorldNode(entity_render_t *ent, q3mnode_t *node, const vec3_t modelorg, qbyte *pvs, int markframe)
+{
+	int i;
+	q3mleaf_t *leaf;
+	q3mface_t *face;
+	while (node->isnode)
+	{
+		if (R_CullBox(node->mins, node->maxs))
+			return;
+		R_Q3BSP_RecursiveWorldNode(ent, node->children[0], modelorg, pvs, markframe);
+		node = node->children[1];
+	}
+	if (R_CullBox(node->mins, node->maxs))
+		return;
+	leaf = (q3mleaf_t *)node;
+	if (pvs[leaf->clusterindex >> 3] & (1 << (leaf->clusterindex & 7)))
+	{
+		for (i = 0;i < leaf->numleaffaces;i++)
+		{
+			face = leaf->firstleafface[i];
+			if (face->markframe != markframe)
+			{
+				face->markframe = markframe;
+				if (!R_CullBox(face->mins, face->maxs))
+					R_Q3BSP_DrawFace(ent, face);
+			}
+		}
+	}
+}
+
+
+
+void R_Q3BSP_Draw(entity_render_t *ent)
+{
+	int i;
+	q3mface_t *face;
+	vec3_t modelorg;
+	model_t *model;
+	qbyte *pvs;
+	static int markframe = 0;
+	R_Mesh_Matrix(&ent->matrix);
+	model = ent->model;
+	if (r_drawcollisionbrushes.integer < 2)
+	{
+		Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
+		if (ent == &cl_entities[0].render && model->brushq3.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++)
+				R_Q3BSP_DrawFace(ent, face);
+	}
+	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);
+		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)
+				R_DrawCollisionBrush(model->brushq3.data_thismodel->firstbrush[i].colbrushf);
+	}
+}
+
+void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
+{
+	int i;
+	q3mface_t *face;
+	vec3_t modelorg, lightmins, lightmaxs;
+	model_t *model;
+	float projectdistance;
+	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_origin, 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->brushq3.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_Volume(face->num_vertices, face->num_triangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+	}
+}
+
+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_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz)
+{
+	if ((face->texture->renderflags & Q3MTEXTURERENDERFLAGS_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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, NULL);
+	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, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, NULL);
+}
+
+void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz)
+{
+	int i;
+	q3mface_t *face;
+	vec3_t modelorg, lightmins, lightmaxs;
+	model_t *model;
+	//qbyte *pvs;
+	//static int markframe = 0;
+	if (r_drawcollisionbrushes.integer < 2)
+	{
+		model = ent->model;
+		R_Mesh_Matrix(&ent->matrix);
+		Matrix4x4_Transform(&ent->inversematrix, r_origin, 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->brushq3.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 ((ent != &cl_entities[0].render || face->visframe == r_framecount) && BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
+					R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz);
+	}
+}
+
 static void gl_surf_start(void)
 {
 }
@@ -1927,13 +2018,12 @@ void GL_Surf_Init(void)
 		dlightdivtable[i] = 4194304 / (i << 7);
 
 	Cvar_RegisterVariable(&r_ambient);
-	Cvar_RegisterVariable(&r_vertexsurfaces);
-	Cvar_RegisterVariable(&r_dlightmap);
 	Cvar_RegisterVariable(&r_drawportals);
 	Cvar_RegisterVariable(&r_testvis);
 	Cvar_RegisterVariable(&r_floatbuildlightmap);
 	Cvar_RegisterVariable(&r_detailtextures);
 	Cvar_RegisterVariable(&r_surfaceworldnode);
+	Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonoffset);
 
 	R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);
 }