From 605b22f83aeabb5aa490df3f6714ca468146dd7e Mon Sep 17 00:00:00 2001
From: havoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Date: Mon, 22 Sep 2003 01:21:54 +0000
Subject: [PATCH] huge (16%) speed gain on surface rendering by eliminating the
 surfmesh chain in q1bsp surfaces, now only allows one mesh per surface and
 the surfmesh_t is embedded in the surface struct

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@3500 d7cf8633-e32d-0410-b094-e92efae38249
---
 cl_screen.c    |  48 +++----
 cl_screen.h    |  12 +-
 cl_video.c     |  12 +-
 gl_draw.c      |   8 +-
 gl_rsurf.c     | 248 +++++++++++++---------------------
 model_alias.c  |   4 +-
 model_brush.c  | 353 ++++++++++++++++++++++++-------------------------
 model_brush.h  |  28 ++--
 model_shared.c |  16 +--
 model_shared.h |   6 +-
 portals.c      |  36 +++--
 r_shadow.c     |   6 +-
 12 files changed, 347 insertions(+), 430 deletions(-)

diff --git a/cl_screen.c b/cl_screen.c
index d28453b7..63668ca6 100644
--- a/cl_screen.c
+++ b/cl_screen.c
@@ -565,21 +565,21 @@ void DrawQ_SuperPic(float x, float y, char *picname, float width, float height,
 			height = pic->height;
 		mesh.texture = pic->tex;
 	}
-	mesh.numtriangles = 2;
-	mesh.numvertices = 4;
-	mesh.element3i = picelements;
-	mesh.vertex3f = floats;
-	mesh.texcoord2f = floats + 12;
-	mesh.color4f = floats + 20;
+	mesh.num_triangles = 2;
+	mesh.num_vertices = 4;
+	mesh.data_element3i = picelements;
+	mesh.data_vertex3f = floats;
+	mesh.data_texcoord2f = floats + 12;
+	mesh.data_color4f = floats + 20;
 	memset(floats, 0, sizeof(floats));
-	mesh.vertex3f[0] = mesh.vertex3f[9] = x;
-	mesh.vertex3f[1] = mesh.vertex3f[4] = y;
-	mesh.vertex3f[3] = mesh.vertex3f[6] = x + width;
-	mesh.vertex3f[7] = mesh.vertex3f[10] = y + height;
-	mesh.texcoord2f[0] = s1;mesh.texcoord2f[1] = t1;mesh.color4f[ 0] = r1;mesh.color4f[ 1] = g1;mesh.color4f[ 2] = b1;mesh.color4f[ 3] = a1;
-	mesh.texcoord2f[2] = s2;mesh.texcoord2f[3] = t2;mesh.color4f[ 4] = r2;mesh.color4f[ 5] = g2;mesh.color4f[ 6] = b2;mesh.color4f[ 7] = a2;
-	mesh.texcoord2f[4] = s4;mesh.texcoord2f[5] = t4;mesh.color4f[ 8] = r4;mesh.color4f[ 9] = g4;mesh.color4f[10] = b4;mesh.color4f[11] = a4;
-	mesh.texcoord2f[6] = s3;mesh.texcoord2f[7] = t3;mesh.color4f[12] = r3;mesh.color4f[13] = g3;mesh.color4f[14] = b3;mesh.color4f[15] = a3;
+	mesh.data_vertex3f[0] = mesh.data_vertex3f[9] = x;
+	mesh.data_vertex3f[1] = mesh.data_vertex3f[4] = y;
+	mesh.data_vertex3f[3] = mesh.data_vertex3f[6] = x + width;
+	mesh.data_vertex3f[7] = mesh.data_vertex3f[10] = y + height;
+	mesh.data_texcoord2f[0] = s1;mesh.data_texcoord2f[1] = t1;mesh.data_color4f[ 0] = r1;mesh.data_color4f[ 1] = g1;mesh.data_color4f[ 2] = b1;mesh.data_color4f[ 3] = a1;
+	mesh.data_texcoord2f[2] = s2;mesh.data_texcoord2f[3] = t2;mesh.data_color4f[ 4] = r2;mesh.data_color4f[ 5] = g2;mesh.data_color4f[ 6] = b2;mesh.data_color4f[ 7] = a2;
+	mesh.data_texcoord2f[4] = s4;mesh.data_texcoord2f[5] = t4;mesh.data_color4f[ 8] = r4;mesh.data_color4f[ 9] = g4;mesh.data_color4f[10] = b4;mesh.data_color4f[11] = a4;
+	mesh.data_texcoord2f[6] = s3;mesh.data_texcoord2f[7] = t3;mesh.data_color4f[12] = r3;mesh.data_color4f[13] = g3;mesh.data_color4f[14] = b3;mesh.data_color4f[15] = a3;
 	DrawQ_Mesh (&mesh, flags);
 }
 
@@ -591,10 +591,10 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
 	drawqueuemesh_t *m;
 	size = sizeof(*dq);
 	size += sizeof(drawqueuemesh_t);
-	size += sizeof(int[3]) * mesh->numtriangles;
-	size += sizeof(float[3]) * mesh->numvertices;
-	size += sizeof(float[2]) * mesh->numvertices;
-	size += sizeof(float[4]) * mesh->numvertices;
+	size += sizeof(int[3]) * mesh->num_triangles;
+	size += sizeof(float[3]) * mesh->num_vertices;
+	size += sizeof(float[2]) * mesh->num_vertices;
+	size += sizeof(float[4]) * mesh->num_vertices;
 	if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
 		return;
 	dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
@@ -608,13 +608,13 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
 	dq->scaley = 0;
 	p = (void *)(dq + 1);
 	m = p;(qbyte *)p += sizeof(drawqueuemesh_t);
-	m->numtriangles = mesh->numtriangles;
-	m->numvertices = mesh->numvertices;
+	m->num_triangles = mesh->num_triangles;
+	m->num_vertices = mesh->num_vertices;
 	m->texture = mesh->texture;
-	m->element3i  = p;memcpy(m->element3i , mesh->element3i , m->numtriangles * sizeof(int[3]));(qbyte *)p += m->numtriangles * sizeof(int[3]);
-	m->vertex3f   = p;memcpy(m->vertex3f  , mesh->vertex3f  , m->numvertices * sizeof(float[3]));(qbyte *)p += m->numvertices * sizeof(float[3]);
-	m->texcoord2f = p;memcpy(m->texcoord2f, mesh->texcoord2f, m->numvertices * sizeof(float[2]));(qbyte *)p += m->numvertices * sizeof(float[2]);
-	m->color4f    = p;memcpy(m->color4f   , mesh->color4f   , m->numvertices * sizeof(float[4]));(qbyte *)p += m->numvertices * sizeof(float[4]);
+	m->data_element3i  = p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));(qbyte *)p += m->num_triangles * sizeof(int[3]);
+	m->data_vertex3f   = p;memcpy(m->data_vertex3f  , mesh->data_vertex3f  , m->num_vertices * sizeof(float[3]));(qbyte *)p += m->num_vertices * sizeof(float[3]);
+	m->data_texcoord2f = p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));(qbyte *)p += m->num_vertices * sizeof(float[2]);
+	m->data_color4f    = p;memcpy(m->data_color4f   , mesh->data_color4f   , m->num_vertices * sizeof(float[4]));(qbyte *)p += m->num_vertices * sizeof(float[4]);
 	r_refdef.drawqueuesize += dq->size;
 }
 
diff --git a/cl_screen.h b/cl_screen.h
index e153b99a..881f5b55 100644
--- a/cl_screen.h
+++ b/cl_screen.h
@@ -22,12 +22,12 @@ drawqueue_t;
 typedef struct drawqueuemesh_s
 {
 	rtexture_t *texture;
-	int numtriangles;
-	int numvertices;
-	int *element3i;
-	float *vertex3f;
-	float *texcoord2f;
-	float *color4f;
+	int num_triangles;
+	int num_vertices;
+	int *data_element3i;
+	float *data_vertex3f;
+	float *data_texcoord2f;
+	float *data_color4f;
 }
 drawqueuemesh_t;
 
diff --git a/cl_video.c b/cl_video.c
index debe4223..b9b215d1 100644
--- a/cl_video.c
+++ b/cl_video.c
@@ -109,12 +109,12 @@ void CL_DrawVideo(void)
 		vertex3f[ 6] = x2;vertex3f[ 7] = y2;vertex3f[ 8] = 0;
 		vertex3f[ 9] = x1;vertex3f[10] = y2;vertex3f[11] = 0;
 		mesh.texture = cl_videotexture;
-		mesh.numtriangles = 2;
-		mesh.numvertices = 4;
-		mesh.element3i = polygonelements;
-		mesh.vertex3f = vertex3f;
-		mesh.texcoord2f = texcoord2f;
-		mesh.color4f = color4f;
+		mesh.num_triangles = 2;
+		mesh.num_vertices = 4;
+		mesh.data_element3i = polygonelements;
+		mesh.data_vertex3f = vertex3f;
+		mesh.data_texcoord2f = texcoord2f;
+		mesh.data_color4f = color4f;
 		DrawQ_Mesh(&mesh, 0);
 		//DrawQ_Pic(0, 0, "engine_videoframe", vid.conwidth, vid.conheight, 1, 1, 1, 1, 0);
 	}
diff --git a/gl_draw.c b/gl_draw.c
index 6304fb8e..3e0d58dd 100644
--- a/gl_draw.c
+++ b/gl_draw.c
@@ -497,12 +497,12 @@ void R_DrawQueue(void)
 			break;
 		case DRAWQUEUE_MESH:
 			mesh = (void *)(dq + 1);
-			GL_VertexPointer(mesh->vertex3f);
-			GL_ColorPointer(mesh->color4f);
+			GL_VertexPointer(mesh->data_vertex3f);
+			GL_ColorPointer(mesh->data_color4f);
 			m.tex[0] = R_GetTexture(mesh->texture);
-			m.pointer_texcoord[0] = mesh->texcoord2f;
+			m.pointer_texcoord[0] = mesh->data_texcoord2f;
 			R_Mesh_State_Texture(&m);
-			R_Mesh_Draw(mesh->numvertices, mesh->numtriangles, mesh->element3i);
+			R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
 			currentpic = "\0";
 			break;
 		}
diff --git a/gl_rsurf.c b/gl_rsurf.c
index e4f37671..ba73451b 100644
--- a/gl_rsurf.c
+++ b/gl_rsurf.c
@@ -703,7 +703,6 @@ static int RSurf_LightSeparate_Vertex3f_Color4f(const matrix4x4_t *matrix, const
 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...
@@ -743,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);
@@ -758,7 +754,6 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 	const entity_render_t *ent = calldata1;
 	const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
 	float colorscale;
-	const surfmesh_t *mesh;
 	rmeshstate_t m;
 	float alpha;
 	float modelorg[3];
@@ -828,20 +823,19 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
 		qglTexEnvfv (GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
 		qglEnable (GL_TEXTURE_SHADER_NV);
 	}
-	for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+
+	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;
-		m.pointer_texcoord[1] = mesh->texcoordtexture2f;
-		m.texcombinergb[1] = GL_REPLACE;
-		R_Mesh_State_Texture(&m);
-		if (fogenabled)
-		{
-			R_FillColors(varray_color4f, mesh->numverts, 1, 1, 1, alpha);
-			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, colorscale, 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.integer)
 	{
 		qglDisable (GL_TEXTURE_SHADER_NV);
@@ -855,15 +849,12 @@ 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, 1, 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)
@@ -899,7 +890,6 @@ static void RSurfShader_Water(const entity_render_t *ent, const texture_t *textu
 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);
@@ -929,27 +919,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);
@@ -959,20 +946,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, 1, 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);
@@ -982,21 +966,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, 1, 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;
@@ -1023,15 +1004,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);
 		}
 	}
 }
@@ -1039,7 +1017,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));
@@ -1061,14 +1038,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);
 		}
 	}
 }
@@ -1076,7 +1050,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);
@@ -1088,13 +1061,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);
 		}
 	}
 }
@@ -1102,7 +1072,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));
@@ -1123,13 +1092,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);
-			}
+			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);
 		}
 	}
 }
@@ -1137,7 +1103,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 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);
@@ -1150,15 +1115,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, 1, 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);
 		}
 	}
 }
@@ -1166,7 +1128,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);
@@ -1178,13 +1139,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);
 		}
 	}
 }
@@ -1192,7 +1150,6 @@ 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);
@@ -1204,13 +1161,10 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t
 	{
 		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);
 		}
 	}
 }
@@ -1218,7 +1172,6 @@ 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);
@@ -1232,13 +1185,10 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(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->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);
 		}
 	}
 }
@@ -1752,7 +1702,6 @@ 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);
@@ -1773,8 +1722,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);
 			}
 		}
 	}
@@ -1785,7 +1733,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);
@@ -1798,11 +1745,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);
 			}
 		}
 	}
@@ -1814,7 +1758,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);
@@ -1837,11 +1780,8 @@ 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);
 				}
 			}
 		}
@@ -1860,7 +1800,7 @@ void R_DrawCollisionBrush(colbrushf_t *brush)
 void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 {
 	rmeshstate_t m;
-	if (!face->numtriangles)
+	if (!face->num_triangles)
 		return;
 	if (face->texture->renderflags)
 	{
@@ -1896,7 +1836,7 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 			R_Mesh_State_Texture(&m);
 
 			GL_VertexPointer(face->data_vertex3f);
-			R_Mesh_Draw(face->numvertices, face->numtriangles, face->data_element3i);
+			R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
 			qglColorMask(1,1,1,1);
 			return;
 		}
@@ -1925,7 +1865,7 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 	}
 	R_Mesh_State_Texture(&m);
 	GL_VertexPointer(face->data_vertex3f);
-	R_Mesh_Draw(face->numvertices, face->numtriangles, face->data_element3i);
+	R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
 }
 
 /*
@@ -2023,16 +1963,16 @@ void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin,
 		//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->numvertices, face->numtriangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+					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->numtriangles)
+	if ((face->texture->renderflags & Q3MTEXTURERENDERFLAGS_NODRAW) || !face->num_triangles)
 		return;
-	R_Shadow_DiffuseLighting(face->numvertices, face->numtriangles, 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->numvertices, face->numtriangles, 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);
+	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)
diff --git a/model_alias.c b/model_alias.c
index c43a37d7..aab89ade 100644
--- a/model_alias.c
+++ b/model_alias.c
@@ -981,8 +981,8 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer)
 	loadmodel->flags = 0; // there are no flags
 	loadmodel->numframes = pheader->numscenes;
 	loadmodel->synctype = ST_SYNC;
-	//loadmodel->numtris = pheader->numtris;
-	//loadmodel->numverts = 0;
+	//loadmodel->num_triangles = pheader->num_triangles;
+	//loadmodel->num_vertices = 0;
 
 	{
 		unsigned int i;
diff --git a/model_brush.c b/model_brush.c
index 92ae090d..a3e80479 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -169,7 +169,6 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in
 	float surfnormal[3];
 #endif
 	msurface_t *surf;
-	surfmesh_t *mesh;
 	for (surfnum = 0, mark = leaf->firstmarksurface;surfnum < leaf->nummarksurfaces;surfnum++, mark++)
 	{
 		surf = info->model->brushq1.surfaces + *mark;
@@ -180,103 +179,100 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in
 			if (surf->flags & SURF_PLANEBACK)
 				VectorNegate(surfnormal, surfnormal);
 #endif
-			for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+			for (k = 0;k < surf->mesh.num_triangles;k++)
 			{
-				for (k = 0;k < mesh->numtriangles;k++)
+				tri = surf->mesh.data_element3i + k * 3;
+				VectorCopy((surf->mesh.data_vertex3f + tri[0] * 3), vert[0]);
+				VectorCopy((surf->mesh.data_vertex3f + tri[1] * 3), vert[1]);
+				VectorCopy((surf->mesh.data_vertex3f + tri[2] * 3), vert[2]);
+				VectorSubtract(vert[1], vert[0], edge[0]);
+				VectorSubtract(vert[2], vert[1], edge[1]);
+				CrossProduct(edge[1], edge[0], facenormal);
+				if (facenormal[0] || facenormal[1] || facenormal[2])
 				{
-					tri = mesh->element3i + k * 3;
-					VectorCopy((mesh->vertex3f + tri[0] * 3), vert[0]);
-					VectorCopy((mesh->vertex3f + tri[1] * 3), vert[1]);
-					VectorCopy((mesh->vertex3f + tri[2] * 3), vert[2]);
-					VectorSubtract(vert[1], vert[0], edge[0]);
-					VectorSubtract(vert[2], vert[1], edge[1]);
-					CrossProduct(edge[1], edge[0], facenormal);
-					if (facenormal[0] || facenormal[1] || facenormal[2])
+					VectorNormalize(facenormal);
+#if 0
+					if (VectorDistance(facenormal, surfnormal) > 0.01f)
+						Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
+#endif
+					f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
+					if (f <= info->bestdist && f >= -info->bestdist)
 					{
-						VectorNormalize(facenormal);
+						VectorSubtract(vert[0], vert[2], edge[2]);
+						VectorNormalize(edge[0]);
+						VectorNormalize(edge[1]);
+						VectorNormalize(edge[2]);
+						CrossProduct(facenormal, edge[0], edgenormal[0]);
+						CrossProduct(facenormal, edge[1], edgenormal[1]);
+						CrossProduct(facenormal, edge[2], edgenormal[2]);
 #if 0
-						if (VectorDistance(facenormal, surfnormal) > 0.01f)
-							Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
+						if (samelevel.integer & 1)
+							VectorNegate(edgenormal[0], edgenormal[0]);
+						if (samelevel.integer & 2)
+							VectorNegate(edgenormal[1], edgenormal[1]);
+						if (samelevel.integer & 4)
+							VectorNegate(edgenormal[2], edgenormal[2]);
+						for (i = 0;i < 3;i++)
+							if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
+							 || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
+							 || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
+								Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
 #endif
-						f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
-						if (f <= info->bestdist && f >= -info->bestdist)
+						// face distance
+						if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
+						 && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
+						 && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
 						{
-							VectorSubtract(vert[0], vert[2], edge[2]);
-							VectorNormalize(edge[0]);
-							VectorNormalize(edge[1]);
-							VectorNormalize(edge[2]);
-							CrossProduct(facenormal, edge[0], edgenormal[0]);
-							CrossProduct(facenormal, edge[1], edgenormal[1]);
-							CrossProduct(facenormal, edge[2], edgenormal[2]);
-#if 0
-							if (samelevel.integer & 1)
-								VectorNegate(edgenormal[0], edgenormal[0]);
-							if (samelevel.integer & 2)
-								VectorNegate(edgenormal[1], edgenormal[1]);
-							if (samelevel.integer & 4)
-								VectorNegate(edgenormal[2], edgenormal[2]);
+							// we got lucky, the center is within the face
+							dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
+							if (dist < 0)
+							{
+								dist = -dist;
+								if (info->bestdist > dist)
+								{
+									info->bestdist = dist;
+									VectorScale(facenormal, (info->radius - -dist), info->nudge);
+								}
+							}
+							else
+							{
+								if (info->bestdist > dist)
+								{
+									info->bestdist = dist;
+									VectorScale(facenormal, (info->radius - dist), info->nudge);
+								}
+							}
+						}
+						else
+						{
+							// check which edge or vertex the center is nearest
 							for (i = 0;i < 3;i++)
-								if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
-								 || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
-								 || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
-									Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
-#endif
-							// face distance
-							if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
-							 && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
-							 && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
 							{
-								// we got lucky, the center is within the face
-								dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
-								if (dist < 0)
+								f = DotProduct(info->center, edge[i]);
+								if (f >= DotProduct(vert[0], edge[i])
+								 && f <= DotProduct(vert[1], edge[i]))
 								{
-									dist = -dist;
+									// on edge
+									VectorMA(info->center, -f, edge[i], point);
+									dist = sqrt(DotProduct(point, point));
 									if (info->bestdist > dist)
 									{
 										info->bestdist = dist;
-										VectorScale(facenormal, (info->radius - -dist), info->nudge);
+										VectorScale(point, (info->radius / dist), info->nudge);
 									}
+									// skip both vertex checks
+									// (both are further away than this edge)
+									i++;
 								}
 								else
 								{
+									// not on edge, check first vertex of edge
+									VectorSubtract(info->center, vert[i], point);
+									dist = sqrt(DotProduct(point, point));
 									if (info->bestdist > dist)
 									{
 										info->bestdist = dist;
-										VectorScale(facenormal, (info->radius - dist), info->nudge);
-									}
-								}
-							}
-							else
-							{
-								// check which edge or vertex the center is nearest
-								for (i = 0;i < 3;i++)
-								{
-									f = DotProduct(info->center, edge[i]);
-									if (f >= DotProduct(vert[0], edge[i])
-									 && f <= DotProduct(vert[1], edge[i]))
-									{
-										// on edge
-										VectorMA(info->center, -f, edge[i], point);
-										dist = sqrt(DotProduct(point, point));
-										if (info->bestdist > dist)
-										{
-											info->bestdist = dist;
-											VectorScale(point, (info->radius / dist), info->nudge);
-										}
-										// skip both vertex checks
-										// (both are further away than this edge)
-										i++;
-									}
-									else
-									{
-										// not on edge, check first vertex of edge
-										VectorSubtract(info->center, vert[i], point);
-										dist = sqrt(DotProduct(point, point));
-										if (info->bestdist > dist)
-										{
-											info->bestdist = dist;
-											VectorScale(point, (info->radius / dist), info->nudge);
-										}
+										VectorScale(point, (info->radius / dist), info->nudge);
 									}
 								}
 							}
@@ -1492,13 +1488,13 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surf)
 		Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?\n");
 
 	surf->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
-	mesh->numverts = subdivpolyverts;
-	mesh->numtriangles = subdivpolytriangles;
+	mesh->num_vertices = subdivpolyverts;
+	mesh->num_triangles = subdivpolytriangles;
 	mesh->vertex = (surfvertex_t *)(mesh + 1);
-	mesh->index = (int *)(mesh->vertex + mesh->numverts);
-	memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
+	mesh->index = (int *)(mesh->vertex + mesh->num_vertices);
+	memset(mesh->vertex, 0, mesh->num_vertices * sizeof(surfvertex_t));
 
-	for (i = 0;i < mesh->numtriangles;i++)
+	for (i = 0;i < mesh->num_triangles;i++)
 		for (j = 0;j < 3;j++)
 			mesh->index[i*3+j] = subdivpolyindex[i][j];
 
@@ -1515,18 +1511,18 @@ static surfmesh_t *Mod_Q1BSP_AllocSurfMesh(int numverts, int numtriangles)
 {
 	surfmesh_t *mesh;
 	mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + numtriangles * sizeof(int[6]) + numverts * (3 + 2 + 2 + 2 + 3 + 3 + 3 + 1) * sizeof(float));
-	mesh->numverts = numverts;
-	mesh->numtriangles = numtriangles;
-	mesh->vertex3f = (float *)(mesh + 1);
-	mesh->texcoordtexture2f = mesh->vertex3f + mesh->numverts * 3;
-	mesh->texcoordlightmap2f = mesh->texcoordtexture2f + mesh->numverts * 2;
-	mesh->texcoorddetail2f = mesh->texcoordlightmap2f + mesh->numverts * 2;
-	mesh->svector3f = (float *)(mesh->texcoorddetail2f + mesh->numverts * 2);
-	mesh->tvector3f = mesh->svector3f + mesh->numverts * 3;
-	mesh->normal3f = mesh->tvector3f + mesh->numverts * 3;
-	mesh->lightmapoffsets = (int *)(mesh->normal3f + mesh->numverts * 3);
-	mesh->element3i = mesh->lightmapoffsets + mesh->numverts;
-	mesh->neighbor3i = mesh->element3i + mesh->numtriangles * 3;
+	mesh->num_vertices = numverts;
+	mesh->num_triangles = numtriangles;
+	mesh->data_vertex3f = (float *)(mesh + 1);
+	mesh->data_texcoordtexture2f = mesh->data_vertex3f + mesh->num_vertices * 3;
+	mesh->data_texcoordlightmap2f = mesh->data_texcoordtexture2f + mesh->num_vertices * 2;
+	mesh->data_texcoorddetail2f = mesh->data_texcoordlightmap2f + mesh->num_vertices * 2;
+	mesh->data_svector3f = (float *)(mesh->data_texcoorddetail2f + mesh->num_vertices * 2);
+	mesh->data_tvector3f = mesh->data_svector3f + mesh->num_vertices * 3;
+	mesh->data_normal3f = mesh->data_tvector3f + mesh->num_vertices * 3;
+	mesh->data_lightmapoffsets = (int *)(mesh->data_normal3f + mesh->num_vertices * 3);
+	mesh->data_element3i = mesh->data_lightmapoffsets + mesh->num_vertices;
+	mesh->data_neighbor3i = mesh->data_element3i + mesh->num_triangles * 3;
 	return mesh;
 }
 
@@ -1665,52 +1661,51 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	}
 
 	loadmodel->brushq1.entiremesh = Mod_Q1BSP_AllocSurfMesh(totalverts, totaltris);
-	loadmodel->brushq1.surfmeshes = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) * totalmeshes);
 
 	for (surfnum = 0, surf = loadmodel->brushq1.surfaces, totalverts = 0, totaltris = 0, totalmeshes = 0;surfnum < count;surfnum++, totalverts += surf->poly_numverts, totaltris += surf->poly_numverts - 2, totalmeshes++, surf++)
 	{
-		mesh = surf->mesh = loadmodel->brushq1.surfmeshes + totalmeshes;
-		mesh->numverts = surf->poly_numverts;
-		mesh->numtriangles = surf->poly_numverts - 2;
-		mesh->vertex3f = loadmodel->brushq1.entiremesh->vertex3f + totalverts * 3;
-		mesh->texcoordtexture2f = loadmodel->brushq1.entiremesh->texcoordtexture2f + totalverts * 2;
-		mesh->texcoordlightmap2f = loadmodel->brushq1.entiremesh->texcoordlightmap2f + totalverts * 2;
-		mesh->texcoorddetail2f = loadmodel->brushq1.entiremesh->texcoorddetail2f + totalverts * 2;
-		mesh->svector3f = loadmodel->brushq1.entiremesh->svector3f + totalverts * 3;
-		mesh->tvector3f = loadmodel->brushq1.entiremesh->tvector3f + totalverts * 3;
-		mesh->normal3f = loadmodel->brushq1.entiremesh->normal3f + totalverts * 3;
-		mesh->lightmapoffsets = loadmodel->brushq1.entiremesh->lightmapoffsets + totalverts;
-		mesh->element3i = loadmodel->brushq1.entiremesh->element3i + totaltris * 3;
-		mesh->neighbor3i = loadmodel->brushq1.entiremesh->neighbor3i + totaltris * 3;
+		mesh = &surf->mesh;
+		mesh->num_vertices = surf->poly_numverts;
+		mesh->num_triangles = surf->poly_numverts - 2;
+		mesh->data_vertex3f = loadmodel->brushq1.entiremesh->data_vertex3f + totalverts * 3;
+		mesh->data_texcoordtexture2f = loadmodel->brushq1.entiremesh->data_texcoordtexture2f + totalverts * 2;
+		mesh->data_texcoordlightmap2f = loadmodel->brushq1.entiremesh->data_texcoordlightmap2f + totalverts * 2;
+		mesh->data_texcoorddetail2f = loadmodel->brushq1.entiremesh->data_texcoorddetail2f + totalverts * 2;
+		mesh->data_svector3f = loadmodel->brushq1.entiremesh->data_svector3f + totalverts * 3;
+		mesh->data_tvector3f = loadmodel->brushq1.entiremesh->data_tvector3f + totalverts * 3;
+		mesh->data_normal3f = loadmodel->brushq1.entiremesh->data_normal3f + totalverts * 3;
+		mesh->data_lightmapoffsets = loadmodel->brushq1.entiremesh->data_lightmapoffsets + totalverts;
+		mesh->data_element3i = loadmodel->brushq1.entiremesh->data_element3i + totaltris * 3;
+		mesh->data_neighbor3i = loadmodel->brushq1.entiremesh->data_neighbor3i + totaltris * 3;
 
 		surf->lightmaptexturestride = 0;
 		surf->lightmaptexture = NULL;
 
-		for (i = 0;i < mesh->numverts;i++)
+		for (i = 0;i < mesh->num_vertices;i++)
 		{
-			mesh->vertex3f[i * 3 + 0] = surf->poly_verts[i * 3 + 0];
-			mesh->vertex3f[i * 3 + 1] = surf->poly_verts[i * 3 + 1];
-			mesh->vertex3f[i * 3 + 2] = surf->poly_verts[i * 3 + 2];
-			s = DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
-			t = DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
-			mesh->texcoordtexture2f[i * 2 + 0] = s / surf->texinfo->texture->width;
-			mesh->texcoordtexture2f[i * 2 + 1] = t / surf->texinfo->texture->height;
-			mesh->texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
-			mesh->texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
-			mesh->texcoordlightmap2f[i * 2 + 0] = 0;
-			mesh->texcoordlightmap2f[i * 2 + 1] = 0;
-			mesh->lightmapoffsets[i] = 0;
+			mesh->data_vertex3f[i * 3 + 0] = surf->poly_verts[i * 3 + 0];
+			mesh->data_vertex3f[i * 3 + 1] = surf->poly_verts[i * 3 + 1];
+			mesh->data_vertex3f[i * 3 + 2] = surf->poly_verts[i * 3 + 2];
+			s = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
+			t = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
+			mesh->data_texcoordtexture2f[i * 2 + 0] = s / surf->texinfo->texture->width;
+			mesh->data_texcoordtexture2f[i * 2 + 1] = t / surf->texinfo->texture->height;
+			mesh->data_texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
+			mesh->data_texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
+			mesh->data_texcoordlightmap2f[i * 2 + 0] = 0;
+			mesh->data_texcoordlightmap2f[i * 2 + 1] = 0;
+			mesh->data_lightmapoffsets[i] = 0;
 		}
 
-		for (i = 0;i < mesh->numtriangles;i++)
+		for (i = 0;i < mesh->num_triangles;i++)
 		{
-			mesh->element3i[i * 3 + 0] = 0;
-			mesh->element3i[i * 3 + 1] = i + 1;
-			mesh->element3i[i * 3 + 2] = i + 2;
+			mesh->data_element3i[i * 3 + 0] = 0;
+			mesh->data_element3i[i * 3 + 1] = i + 1;
+			mesh->data_element3i[i * 3 + 2] = i + 2;
 		}
 
-		Mod_BuildTriangleNeighbors(mesh->neighbor3i, mesh->element3i, mesh->numtriangles);
-		Mod_BuildTextureVectorsAndNormals(mesh->numverts, mesh->numtriangles, mesh->vertex3f, mesh->texcoordtexture2f, mesh->element3i, mesh->svector3f, mesh->tvector3f, mesh->normal3f);
+		Mod_BuildTriangleNeighbors(mesh->data_neighbor3i, mesh->data_element3i, mesh->num_triangles);
+		Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, mesh->data_vertex3f, mesh->data_texcoordtexture2f, mesh->data_element3i, mesh->data_svector3f, mesh->data_tvector3f, mesh->data_normal3f);
 
 		if (surf->texinfo->texture->shader == &Cshader_wall_lightmap)
 		{
@@ -1735,16 +1730,16 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			uscale = (uscale - ubase) / (smax + 1);
 			vscale = (vscale - vbase) / (tmax + 1);
 
-			for (i = 0;i < mesh->numverts;i++)
+			for (i = 0;i < mesh->num_vertices;i++)
 			{
-				u = ((DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) + 8 - surf->texturemins[0]) * (1.0 / 16.0);
-				v = ((DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) + 8 - surf->texturemins[1]) * (1.0 / 16.0);
-				mesh->texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
-				mesh->texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
+				u = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) + 8 - surf->texturemins[0]) * (1.0 / 16.0);
+				v = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) + 8 - surf->texturemins[1]) * (1.0 / 16.0);
+				mesh->data_texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
+				mesh->data_texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
 				// LordHavoc: calc lightmap data offset for vertex lighting to use
 				iu = (int) u;
 				iv = (int) v;
-				mesh->lightmapoffsets[i] = (bound(0, iv, tmax) * (smax+1) + bound(0, iu, smax)) * 3;
+				mesh->data_lightmapoffsets[i] = (bound(0, iv, tmax) * (smax+1) + bound(0, iu, smax)) * 3;
 			}
 		}
 	}
@@ -2655,7 +2650,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	model_t *originalloadmodel;
 	float dist, modelyawradius, modelradius, *vec;
 	msurface_t *surf;
-	surfmesh_t *mesh;
 
 	mod->type = mod_brush;
 
@@ -2775,23 +2769,20 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 				if (mod->brush.numsubmodels - 1)
 					surf->flags |= SURF_SOLIDCLIP;
 				// calculate bounding shapes
-				for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+				for (k = 0, vec = surf->mesh.data_vertex3f;k < surf->mesh.num_vertices;k++, vec += 3)
 				{
-					for (k = 0, vec = mesh->vertex3f;k < mesh->numverts;k++, vec += 3)
-					{
-						if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
-						if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
-						if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
-						if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
-						if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
-						if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
-						dist = vec[0]*vec[0]+vec[1]*vec[1];
-						if (modelyawradius < dist)
-							modelyawradius = dist;
-						dist += vec[2]*vec[2];
-						if (modelradius < dist)
-							modelradius = dist;
-					}
+					if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
+					if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
+					if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
+					if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
+					if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
+					if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
+					dist = vec[0]*vec[0]+vec[1]*vec[1];
+					if (modelyawradius < dist)
+						modelyawradius = dist;
+					dist += vec[2]*vec[2];
+					if (modelradius < dist)
+						modelradius = dist;
 				}
 			}
 			modelyawradius = sqrt(modelyawradius);
@@ -3629,25 +3620,24 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
 
 		out->firstvertex = LittleLong(in->firstvertex);
-		out->numvertices = LittleLong(in->numvertices);
+		out->num_vertices = LittleLong(in->numvertices);
 		out->firstelement = LittleLong(in->firstelement);
-		out->numelements = LittleLong(in->numelements);
-		out->numtriangles = out->numelements / 3;
-		if (out->firstvertex < 0 || out->firstvertex + out->numvertices > loadmodel->brushq3.num_vertices)
+		out->num_triangles = LittleLong(in->numelements) / 3;
+		if (out->num_triangles * 3 != LittleLong(in->numelements))
 		{
-			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->numvertices, loadmodel->brushq3.num_vertices);
+			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
 			out->type = 0; // error
 			continue;
 		}
-		if (out->firstelement < 0 || out->firstelement + out->numelements > loadmodel->brushq3.num_triangles * 3)
+		if (out->firstvertex < 0 || out->firstvertex + out->num_vertices > loadmodel->brushq3.num_vertices)
 		{
-			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->numelements, loadmodel->brushq3.num_triangles * 3);
+			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->num_vertices, loadmodel->brushq3.num_vertices);
 			out->type = 0; // error
 			continue;
 		}
-		if (out->numtriangles * 3 != out->numelements)
+		if (out->firstelement < 0 || out->firstelement + out->num_triangles * 3 > loadmodel->brushq3.num_triangles * 3)
 		{
-			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, out->numelements);
+			Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->num_triangles * 3, loadmodel->brushq3.num_triangles * 3);
 			out->type = 0; // error
 			continue;
 		}
@@ -3702,10 +3692,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			out->data_neighbor3i = out->data_element3i + finaltriangles * 3;
 			out->type = Q3FACETYPE_MESH;
 			out->firstvertex = -1;
-			out->numvertices = finalvertices;
+			out->num_vertices = finalvertices;
 			out->firstelement = -1;
-			out->numtriangles = finaltriangles;
-			out->numelements = finaltriangles * 3;
+			out->num_triangles = finaltriangles;
 			// generate geometry
 			// (note: normals are skipped because they get recalculated)
 			QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_vertex3f);
@@ -3730,13 +3719,13 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 					row1++;
 				}
 			}
-			out->numtriangles = Mod_RemoveDegenerateTriangles(out->numtriangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
+			out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
 			if (developer.integer)
 			{
-				if (out->numtriangles < finaltriangles)
-					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->numvertices, finaltriangles, finaltriangles - out->numtriangles, out->numtriangles);
+				if (out->num_triangles < finaltriangles)
+					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
 				else
-					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->numvertices, out->numtriangles);
+					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
 			}
 			// q3map does not put in collision brushes for curves... ugh
 			out->collisions = true;
@@ -3744,35 +3733,35 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		case Q3FACETYPE_FLARE:
 			Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
 			// don't render it
-			out->numtriangles = 0;
+			out->num_triangles = 0;
 			break;
 		}
-		for (j = 0, invalidelements = 0;j < out->numelements;j++)
-			if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->numvertices)
+		for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
+			if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
 				invalidelements++;
 		if (invalidelements)
 		{
-			Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->numvertices, out->firstelement, out->numelements);
-			for (j = 0;j < out->numelements;j++)
+			Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->num_vertices, out->firstelement, out->num_triangles * 3);
+			for (j = 0;j < out->num_triangles * 3;j++)
 			{
 				Con_Printf(" %i", out->data_element3i[j]);
-				if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->numvertices)
+				if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
 					out->data_element3i[j] = 0;
 			}
 			Con_Printf("\n");
 		}
 		// for shadow volumes
-		Mod_BuildTriangleNeighbors(out->data_neighbor3i, out->data_element3i, out->numtriangles);
+		Mod_BuildTriangleNeighbors(out->data_neighbor3i, out->data_element3i, out->num_triangles);
 		// for per pixel lighting
-		Mod_BuildTextureVectorsAndNormals(out->numvertices, out->numtriangles, out->data_vertex3f, out->data_texcoordtexture2f, out->data_element3i, out->data_svector3f, out->data_tvector3f, out->data_normal3f);
+		Mod_BuildTextureVectorsAndNormals(out->num_vertices, out->num_triangles, out->data_vertex3f, out->data_texcoordtexture2f, out->data_element3i, out->data_svector3f, out->data_tvector3f, out->data_normal3f);
 		// calculate a bounding box
 		VectorClear(out->mins);
 		VectorClear(out->maxs);
-		if (out->numvertices)
+		if (out->num_vertices)
 		{
 			VectorCopy(out->data_vertex3f, out->mins);
 			VectorCopy(out->data_vertex3f, out->maxs);
-			for (j = 1, v = out->data_vertex3f + 3;j < out->numvertices;j++, v += 3)
+			for (j = 1, v = out->data_vertex3f + 3;j < out->num_vertices;j++, v += 3)
 			{
 				out->mins[0] = min(out->mins[0], v[0]);
 				out->maxs[0] = max(out->maxs[0], v[0]);
@@ -4167,7 +4156,7 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, q3mnode_t *node
 			{
 				face->collisionmarkframe = markframe;
 				if (BoxesOverlap(segmentmins, segmentmaxs, face->mins, face->maxs))
-					Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+					Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
 			}
 		}
 	}
@@ -4251,7 +4240,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, q3mnode_t *nod
 				face = leaf->firstleafface[i];
 				// note: this can not be optimized with a face->collisionmarkframe because each triangle of the face would need to be marked as done individually (because each one is bbox culled individually), and if all are marked, then the face could be marked as done
 				if (face->collisions && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
-					Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+					Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
 			}
 		}
 	}
@@ -4290,7 +4279,7 @@ static void Mod_Q3BSP_TraceBox(model_t *model, trace_t *trace, const vec3_t boxs
 				{
 					face = model->brushq3.data_thismodel->firstface + i;
 					if (face->collisions)
-						Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+						Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
 				}
 			}
 		}
@@ -4313,7 +4302,7 @@ static void Mod_Q3BSP_TraceBox(model_t *model, trace_t *trace, const vec3_t boxs
 				{
 					face = model->brushq3.data_thismodel->firstface + i;
 					if (face->collisions)
-						Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+						Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
 				}
 			}
 		}
diff --git a/model_brush.h b/model_brush.h
index 17e69353..609793c4 100644
--- a/model_brush.h
+++ b/model_brush.h
@@ -145,20 +145,18 @@ mtexinfo_t;
 // LordHavoc: replaces glpoly, triangle mesh
 typedef struct surfmesh_s
 {
-	// can be multiple meshs per surface
-	struct surfmesh_s *chain;
-	int numverts; // number of vertices in the mesh
-	int numtriangles; // number of triangles in the mesh
-	float *vertex3f; // float[verts*3] vertex locations
-	float *svector3f; // float[verts*3] direction of 'S' (right) texture axis for each vertex
-	float *tvector3f; // float[verts*3] direction of 'T' (down) texture axis for each vertex
-	float *normal3f; // float[verts*3] direction of 'R' (out) texture axis for each vertex
-	int *lightmapoffsets; // index into surface's lightmap samples for vertex lighting
-	float *texcoordtexture2f; // float[verts*2] texcoords for surface texture
-	float *texcoordlightmap2f; // float[verts*2] texcoords for lightmap texture
-	float *texcoorddetail2f; // float[verts*2] texcoords for detail texture
-	int *element3i; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
-	int *neighbor3i; // int[tris*3] neighboring triangle on each edge (-1 if none)
+	int num_vertices; // number of vertices in the mesh
+	int num_triangles; // number of triangles in the mesh
+	float *data_vertex3f; // float[verts*3] vertex locations
+	float *data_svector3f; // float[verts*3] direction of 'S' (right) texture axis for each vertex
+	float *data_tvector3f; // float[verts*3] direction of 'T' (down) texture axis for each vertex
+	float *data_normal3f; // float[verts*3] direction of 'R' (out) texture axis for each vertex
+	int *data_lightmapoffsets; // index into surface's lightmap samples for vertex lighting
+	float *data_texcoordtexture2f; // float[verts*2] texcoords for surface texture
+	float *data_texcoordlightmap2f; // float[verts*2] texcoords for lightmap texture
+	float *data_texcoorddetail2f; // float[verts*2] texcoords for detail texture
+	int *data_element3i; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
+	int *data_neighbor3i; // int[tris*3] neighboring triangle on each edge (-1 if none)
 }
 surfmesh_t;
 
@@ -178,7 +176,7 @@ typedef struct msurface_s
 	// the lightmap texture fragment to use on the rendering mesh
 	rtexture_t *lightmaptexture;
 	// mesh for rendering
-	surfmesh_t *mesh;
+	surfmesh_t mesh;
 	// if lightmap settings changed, this forces update
 	int cached_dlight;
 
diff --git a/model_shared.c b/model_shared.c
index 5c578e36..4126b4af 100644
--- a/model_shared.c
+++ b/model_shared.c
@@ -655,7 +655,7 @@ void Mod_ShadowMesh_AddPolygon(mempool_t *mempool, shadowmesh_t *mesh, int numve
 	/*
 	int i, i1, i2, i3;
 	float *v;
-	while (mesh->numverts + numverts > mesh->maxverts || mesh->numtriangles + (numverts - 2) > mesh->maxtriangles)
+	while (mesh->num_vertices + numverts > mesh->maxverts || mesh->num_triangles + (numverts - 2) > mesh->maxtriangles)
 	{
 		if (mesh->next == NULL)
 			mesh->next = Mod_ShadowMesh_Alloc(mempool, max(mesh->maxtriangles, numverts));
@@ -668,10 +668,10 @@ void Mod_ShadowMesh_AddPolygon(mempool_t *mempool, shadowmesh_t *mesh, int numve
 	{
 		i2 = i3;
 		i3 = Mod_ShadowMesh_AddVertex(mesh, v);
-		mesh->elements[mesh->numtriangles * 3 + 0] = i1;
-		mesh->elements[mesh->numtriangles * 3 + 1] = i2;
-		mesh->elements[mesh->numtriangles * 3 + 2] = i3;
-		mesh->numtriangles++;
+		mesh->elements[mesh->num_triangles * 3 + 0] = i1;
+		mesh->elements[mesh->num_triangles * 3 + 1] = i2;
+		mesh->elements[mesh->num_triangles * 3 + 2] = i3;
+		mesh->num_triangles++;
 	}
 	*/
 }
@@ -703,7 +703,7 @@ shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh)
 			newmesh->next = firstmesh;
 			firstmesh = newmesh;
 			//Con_Printf("mesh\n");
-			//for (i = 0;i < newmesh->numtriangles;i++)
+			//for (i = 0;i < newmesh->num_triangles;i++)
 			//	Con_Printf("tri %d %d %d\n", newmesh->elements[i * 3 + 0], newmesh->elements[i * 3 + 1], newmesh->elements[i * 3 + 2]);
 			Mod_ValidateElements(newmesh->element3i, newmesh->numtriangles, newmesh->numverts, __FILE__, __LINE__);
 			Mod_BuildTriangleNeighbors(newmesh->neighbor3i, newmesh->element3i, newmesh->numtriangles);
@@ -714,8 +714,8 @@ shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh)
 	shadowmesh_t *mesh;
 	for (mesh = firstmesh;mesh;mesh = mesh->next)
 	{
-		Mod_ValidateElements(mesh->elements, mesh->numtriangles, mesh->numverts, __FILE__, __LINE__);
-		Mod_BuildTriangleNeighbors(mesh->neighbors, mesh->elements, mesh->numtriangles);
+		Mod_ValidateElements(mesh->elements, mesh->num_triangles, mesh->num_vertices, __FILE__, __LINE__);
+		Mod_BuildTriangleNeighbors(mesh->neighbors, mesh->elements, mesh->num_triangles);
 	}
 #endif
 	return firstmesh;
diff --git a/model_shared.h b/model_shared.h
index e87a9133..92a42aee 100644
--- a/model_shared.h
+++ b/model_shared.h
@@ -202,7 +202,6 @@ typedef struct model_brushq1_s
 	int				*surfacepvsframes;
 	msurface_t		*surfacepvsnext;
 	surfmesh_t		*entiremesh;
-	surfmesh_t		*surfmeshes;
 
 	int				numsurfedges;
 	int				*surfedges;
@@ -358,9 +357,7 @@ typedef struct q3mface_s
 	int collisionmarkframe; // don't collide twice in one trace
 	int type;
 	int firstvertex;
-	int numvertices;
 	int firstelement;
-	int numelements;
 	int patchsize[2];
 	// used for processing
 	int markframe;
@@ -370,6 +367,8 @@ typedef struct q3mface_s
 	float mins[3];
 	float maxs[3];
 
+	int num_vertices;
+	int num_triangles;
 	float *data_vertex3f;
 	float *data_texcoordtexture2f;
 	float *data_texcoordlightmap2f;
@@ -377,7 +376,6 @@ typedef struct q3mface_s
 	float *data_tvector3f;
 	float *data_normal3f;
 	float *data_color4f;
-	int numtriangles;
 	int *data_element3i;
 	int *data_neighbor3i;
 }
diff --git a/portals.c b/portals.c
index 725374b1..da91b8f4 100644
--- a/portals.c
+++ b/portals.c
@@ -339,7 +339,6 @@ void Portal_RecursiveFlow_ExactMarkSurfaces(portalrecursioninfo_t *info, int *ma
 	int i, j, *elements;
 	vec3_t trimins, trimaxs;
 	msurface_t *surf;
-	surfmesh_t *surfmesh;
 	for (i = 0;i < nummarksurfaces;i++, mark++)
 	{
 		if (!info->surfacemark[*mark])
@@ -362,30 +361,25 @@ void Portal_RecursiveFlow_ExactMarkSurfaces(portalrecursioninfo_t *info, int *ma
 			}
 			else
 			{
-				for (surfmesh = surf->mesh;surfmesh;surfmesh = surfmesh->chain)
+				for (j = 0, elements = surf->mesh.data_element3i;j < surf->mesh.num_triangles;j++, elements += 3)
 				{
-					for (j = 0, elements = surfmesh->element3i;j < surfmesh->numtriangles;j++, elements += 3)
+					VectorCopy((surf->mesh.data_vertex3f + elements[0] * 3), trianglepoints[0]);
+					VectorCopy((surf->mesh.data_vertex3f + elements[1] * 3), trianglepoints[1]);
+					VectorCopy((surf->mesh.data_vertex3f + elements[2] * 3), trianglepoints[2]);
+					if (PointInfrontOfTriangle(info->eye, trianglepoints[0], trianglepoints[1], trianglepoints[2]))
 					{
-						VectorCopy((surfmesh->vertex3f + elements[0] * 3), trianglepoints[0]);
-						VectorCopy((surfmesh->vertex3f + elements[1] * 3), trianglepoints[1]);
-						VectorCopy((surfmesh->vertex3f + elements[2] * 3), trianglepoints[2]);
-						if (PointInfrontOfTriangle(info->eye, trianglepoints[0], trianglepoints[1], trianglepoints[2]))
-						{
-							trimins[0] = min(trianglepoints[0][0], min(trianglepoints[1][0], trianglepoints[2][0]));
-							trimaxs[0] = max(trianglepoints[0][0], max(trianglepoints[1][0], trianglepoints[2][0]));
-							trimins[1] = min(trianglepoints[0][1], min(trianglepoints[1][1], trianglepoints[2][1]));
-							trimaxs[1] = max(trianglepoints[0][1], max(trianglepoints[1][1], trianglepoints[2][1]));
-							trimins[2] = min(trianglepoints[0][2], min(trianglepoints[1][2], trianglepoints[2][2]));
-							trimaxs[2] = max(trianglepoints[0][2], max(trianglepoints[1][2], trianglepoints[2][2]));
-							if (BoxesOverlap(trimins, trimaxs, info->boxmins, info->boxmaxs))
-								if (Portal_PortalThroughPortalPlanes(&portalplanes[firstclipplane], numclipplanes, trianglepoints[0], 3, &portaltemppoints2[0][0], 256) >= 3)
-									break;
-						}
+						trimins[0] = min(trianglepoints[0][0], min(trianglepoints[1][0], trianglepoints[2][0]));
+						trimaxs[0] = max(trianglepoints[0][0], max(trianglepoints[1][0], trianglepoints[2][0]));
+						trimins[1] = min(trianglepoints[0][1], min(trianglepoints[1][1], trianglepoints[2][1]));
+						trimaxs[1] = max(trianglepoints[0][1], max(trianglepoints[1][1], trianglepoints[2][1]));
+						trimins[2] = min(trianglepoints[0][2], min(trianglepoints[1][2], trianglepoints[2][2]));
+						trimaxs[2] = max(trianglepoints[0][2], max(trianglepoints[1][2], trianglepoints[2][2]));
+						if (BoxesOverlap(trimins, trimaxs, info->boxmins, info->boxmaxs))
+							if (Portal_PortalThroughPortalPlanes(&portalplanes[firstclipplane], numclipplanes, trianglepoints[0], 3, &portaltemppoints2[0][0], 256) >= 3)
+								break;
 					}
-					if (j < surfmesh->numtriangles)
-						break;
 				}
-				if (surfmesh == NULL)
+				if (j == surf->mesh.num_triangles)
 					continue;
 			}
 			info->surfacemark[*mark] = true;
diff --git a/r_shadow.c b/r_shadow.c
index 97823785..52e4f350 100644
--- a/r_shadow.c
+++ b/r_shadow.c
@@ -1711,7 +1711,6 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style
 	shadowmesh_t *mesh, *castmesh;
 	mleaf_t *leaf;
 	msurface_t *surf;
-	surfmesh_t *surfmesh;
 
 	if (radius < 15 || DotProduct(color, color) < 0.03)
 	{
@@ -1840,9 +1839,8 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style
 			// make a mesh to cast a shadow volume from
 			castmesh = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768);
 			for (j = 0;j < e->numsurfaces;j++)
-				if (e->surfaces[j]->castshadow == castshadowcount)
-					for (surfmesh = e->surfaces[j]->mesh;surfmesh;surfmesh = surfmesh->chain)
-						Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surfmesh->vertex3f, surfmesh->numtriangles, surfmesh->element3i);
+				if ((surf = e->surfaces[j])->castshadow == castshadowcount)
+					Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surf->mesh.data_vertex3f, surf->mesh.num_triangles, surf->mesh.data_element3i);
 			castmesh = Mod_ShadowMesh_Finish(r_shadow_mempool, castmesh);
 
 			// cast shadow volume from castmesh
-- 
2.39.2