X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=model_shared.c;h=058396c4ce26edb5feb678e514994ce2b60e496c;hb=9e883a148a3370e139b78a19d2ee645fba8db8d1;hp=ae555e8540b7801599a12027c4bf8a587c619b96;hpb=cdbfdb392f82ca6770a15238094be0c3448df1a5;p=xonotic%2Fdarkplaces.git

diff --git a/model_shared.c b/model_shared.c
index ae555e85..058396c4 100644
--- a/model_shared.c
+++ b/model_shared.c
@@ -26,30 +26,21 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "image.h"
 #include "r_shadow.h"
 
-cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps skins (so they become blurrier in the distance), disabled by default because it tends to blur with strange border colors from the skin"};
+cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps model skins so they render faster in the distance and do not display noise artifacts, can cause discoloration of skins if they contain undesirable border colors"};
 
 model_t *loadmodel;
 
-#if 0
-// LordHavoc: was 512
-static int mod_numknown = 0;
-static int mod_maxknown = 0;
-static model_t *mod_known = NULL;
-#else
-// LordHavoc: was 512
-#define MAX_MOD_KNOWN (MAX_MODELS + 256)
-static int mod_numknown = 0;
-static int mod_maxknown = MAX_MOD_KNOWN;
-static model_t mod_known[MAX_MOD_KNOWN];
-#endif
+static mempool_t *mod_mempool;
+static memexpandablearray_t models;
 
 static void mod_start(void)
 {
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
 
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
-		if (mod->name[0])
+	for (i = 0;i < nummodels;i++)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && mod->name[0] != '*')
 			if (mod->used)
 				Mod_LoadModel(mod, true, false, mod->isworldmodel);
 }
@@ -57,26 +48,45 @@ static void mod_start(void)
 static void mod_shutdown(void)
 {
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
 
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
-		if (mod->loaded)
+	for (i = 0;i < nummodels;i++)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && (mod->loaded || mod->mempool))
 			Mod_UnloadModel(mod);
 }
 
 static void mod_newmap(void)
 {
 	msurface_t *surface;
-	int i, surfacenum, ssize, tsize;
+	int i, j, k, surfacenum, ssize, tsize;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
+	model_t *mod;
+
+	R_SkinFrame_PrepareForPurge();
+	for (i = 0;i < nummodels;i++)
+	{
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->mempool && mod->data_textures)
+		{
+			for (j = 0;j < mod->num_textures;j++)
+			{
+				for (k = 0;k < mod->data_textures[j].numskinframes;k++)
+					R_SkinFrame_MarkUsed(mod->data_textures[j].skinframes[k]);
+				for (k = 0;k < mod->data_textures[j].backgroundnumskinframes;k++)
+					R_SkinFrame_MarkUsed(mod->data_textures[j].backgroundskinframes[k]);
+			}
+		}
+	}
+	R_SkinFrame_Purge();
 
 	if (!cl_stainmaps_clearonload.integer)
 		return;
 
-	for (i = 0;i < mod_numknown;i++)
+	for (i = 0;i < nummodels;i++)
 	{
-		if (mod_known[i].mempool && mod_known[i].data_surfaces)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->mempool && mod->data_surfaces)
 		{
-			for (surfacenum = 0, surface = mod_known[i].data_surfaces;surfacenum < mod_known[i].num_surfaces;surfacenum++, surface++)
+			for (surfacenum = 0, surface = mod->data_surfaces;surfacenum < mod->num_surfaces;surfacenum++, surface++)
 			{
 				if (surface->lightmapinfo && surface->lightmapinfo->stainsamples)
 				{
@@ -97,8 +107,12 @@ Mod_Init
 */
 static void Mod_Print(void);
 static void Mod_Precache (void);
+static void Mod_BuildVBOs(void);
 void Mod_Init (void)
 {
+	mod_mempool = Mem_AllocPool("modelinfo", 0, NULL);
+	Mem_ExpandableArray_NewArray(&models, mod_mempool, sizeof(model_t), 16);
+
 	Mod_BrushInit();
 	Mod_AliasInit();
 	Mod_SpriteInit();
@@ -118,16 +132,20 @@ void Mod_UnloadModel (model_t *mod)
 	char name[MAX_QPATH];
 	qboolean isworldmodel;
 	qboolean used;
-	strcpy(name, mod->name);
+	strlcpy(name, mod->name, sizeof(name));
 	isworldmodel = mod->isworldmodel;
 	used = mod->used;
+	if (mod->surfmesh.ebo)
+		R_Mesh_DestroyBufferObject(mod->surfmesh.ebo);
+	if (mod->surfmesh.vbo)
+		R_Mesh_DestroyBufferObject(mod->surfmesh.vbo);
 	// free textures/memory attached to the model
 	R_FreeTexturePool(&mod->texturepool);
 	Mem_FreePool(&mod->mempool);
 	// clear the struct to make it available
 	memset(mod, 0, sizeof(model_t));
 	// restore the fields we want to preserve
-	strcpy(mod->name, name);
+	strlcpy(mod->name, name, sizeof(mod->name));
 	mod->isworldmodel = isworldmodel;
 	mod->used = used;
 	mod->loaded = false;
@@ -154,8 +172,16 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
 
 	crc = 0;
 	buf = NULL;
+
+	// even if the model is loaded it still may need reloading...
+
+	// if the model is a worldmodel and is being referred to as a
+	// non-worldmodel here, then it needs reloading to get rid of the
+	// submodels
 	if (mod->isworldmodel != isworldmodel)
 		mod->loaded = false;
+
+	// if it is not loaded or checkdisk is true we need to calculate the crc
 	if (!mod->loaded || checkdisk)
 	{
 		if (checkdisk && mod->loaded)
@@ -164,13 +190,15 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
 		if (buf)
 		{
 			crc = CRC_Block((unsigned char *)buf, filesize);
+			// we need to reload the model if the crc does not match
 			if (mod->crc != crc)
 				mod->loaded = false;
 		}
 	}
+
+	// if the model is already loaded and checks passed, just return
 	if (mod->loaded)
 	{
-		// already loaded
 		if (buf)
 			Mem_Free(buf);
 		return mod;
@@ -178,7 +206,7 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
 
 	Con_DPrintf("loading model %s\n", mod->name);
 	// LordHavoc: unload the existing model in this slot (if there is one)
-	if (mod->loaded)
+	if (mod->loaded || mod->mempool)
 		Mod_UnloadModel(mod);
 
 	// load the model
@@ -197,15 +225,13 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
 	VectorSet(mod->rotatedmins, -mod->radius, -mod->radius, -mod->radius);
 	VectorSet(mod->rotatedmaxs, mod->radius, mod->radius, mod->radius);
 
-	// all models use memory, so allocate a memory pool
-	mod->mempool = Mem_AllocPool(mod->name, 0, NULL);
-	// all models load textures, so allocate a texture pool
-	if (cls.state != ca_dedicated)
-		mod->texturepool = R_AllocTexturePool();
-
 	if (buf)
 	{
 		char *bufend = (char *)buf + filesize;
+
+		// all models use memory, so allocate a memory pool
+		mod->mempool = Mem_AllocPool(mod->name, 0, NULL);
+
 		num = LittleLong(*((int *)buf));
 		// call the apropriate loader
 		loadmodel = mod;
@@ -223,50 +249,54 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean checkdisk, qboolea
 		else if (num == BSPVERSION || num == 30) Mod_Q1BSP_Load(mod, buf, bufend);
 		else Con_Printf("Mod_LoadModel: model \"%s\" is of unknown/unsupported type\n", mod->name);
 		Mem_Free(buf);
+
+		Mod_BuildVBOs();
+
+		// no fatal errors occurred, so this model is ready to use.
+		mod->loaded = true;
 	}
 	else if (crash)
 	{
 		// LordHavoc: Sys_Error was *ANNOYING*
 		Con_Printf ("Mod_LoadModel: %s not found\n", mod->name);
 	}
-
-	// no errors occurred
-	mod->loaded = true;
 	return mod;
 }
 
 void Mod_ClearUsed(void)
 {
-#if 0
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
-
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
-		if (mod->name[0])
+	for (i = 0;i < nummodels;i++)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0])
 			mod->used = false;
-#endif
 }
 
 void Mod_PurgeUnused(void)
 {
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
-
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
-		if (mod->name[0])
-			if (!mod->used)
-				Mod_UnloadModel(mod);
+	for (i = 0;i < nummodels;i++)
+	{
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && !mod->used)
+		{
+			Mod_UnloadModel(mod);
+			Mem_ExpandableArray_FreeRecord(&models, mod);
+		}
+	}
 }
 
 // only used during loading!
 void Mod_RemoveStaleWorldModels(model_t *skip)
 {
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
-
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
+	for (i = 0;i < nummodels;i++)
 	{
-		if (mod->isworldmodel && mod->loaded && skip != mod)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->isworldmodel && mod->loaded && skip != mod)
 		{
 			Mod_UnloadModel(mod);
 			mod->isworldmodel = false;
@@ -284,46 +314,25 @@ Mod_FindName
 model_t *Mod_FindName(const char *name)
 {
 	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
 	model_t *mod;
 
 	if (!name[0])
 		Host_Error ("Mod_ForName: NULL name");
 
-// search the currently loaded models
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
+	// search the currently loaded models
+	for (i = 0;i < nummodels;i++)
 	{
-		if (mod->name[0] && !strcmp(mod->name, name))
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && !strcmp(mod->name, name))
 		{
 			mod->used = true;
 			return mod;
 		}
 	}
 
-	// no match found, find room for a new one
-	for (i = 0;i < mod_numknown;i++)
-		if (!mod_known[i].name[0])
-			break;
-
-	if (mod_maxknown == i)
-	{
-#if 0
-		model_t *old;
-		mod_maxknown += 256;
-		old = mod_known;
-		mod_known = Mem_Alloc(mod_mempool, mod_maxknown * sizeof(model_t));
-		if (old)
-		{
-			memcpy(mod_known, old, mod_numknown * sizeof(model_t));
-			Mem_Free(old);
-		}
-#else
-		Host_Error ("Mod_FindName: ran out of models");
-#endif
-	}
-	if (mod_numknown == i)
-		mod_numknown++;
-	mod = mod_known + i;
-	strcpy (mod->name, name);
+	// no match found, create a new one
+	mod = Mem_ExpandableArray_AllocRecord(&models);
+	strlcpy(mod->name, name, sizeof(mod->name));
 	mod->loaded = false;
 	mod->used = true;
 	return mod;
@@ -345,6 +354,23 @@ model_t *Mod_ForName(const char *name, qboolean crash, qboolean checkdisk, qbool
 	return model;
 }
 
+/*
+==================
+Mod_Reload
+
+Reloads all models if they have changed
+==================
+*/
+void Mod_Reload(void)
+{
+	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
+	model_t *mod;
+	for (i = 0;i < nummodels;i++)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && mod->name[0] != '*' && mod->used)
+			Mod_LoadModel(mod, true, true, mod->isworldmodel);
+}
+
 unsigned char *mod_base;
 
 
@@ -357,13 +383,14 @@ Mod_Print
 */
 static void Mod_Print(void)
 {
-	int		i;
-	model_t	*mod;
+	int i;
+	int nummodels = Mem_ExpandableArray_IndexRange(&models);
+	model_t *mod;
 
 	Con_Print("Loaded models:\n");
-	for (i = 0, mod = mod_known;i < mod_numknown;i++, mod++)
-		if (mod->name[0])
-			Con_Printf("%4iK %s\n", mod->mempool ? (mod->mempool->totalsize + 1023) / 1024 : 0, mod->name);
+	for (i = 0;i < nummodels;i++)
+		if ((mod = Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0])
+			Con_Printf("%4iK %s\n", mod->mempool ? (int)((mod->mempool->totalsize + 1023) / 1024) : 0, mod->name);
 }
 
 /*
@@ -605,20 +632,16 @@ void Mod_BuildBumpVectors(const float *v0, const float *v1, const float *v2, con
 }
 
 // warning: this is a very expensive function!
-void Mod_BuildTextureVectorsAndNormals(int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const float *texcoord2f, const int *elements, float *svector3f, float *tvector3f, float *normal3f, qboolean areaweighting)
+void Mod_BuildTextureVectorsFromNormals(int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const float *texcoord2f, const float *normal3f, const int *elements, float *svector3f, float *tvector3f, qboolean areaweighting)
 {
 	int i, tnum;
-	float sdir[3], tdir[3], normal[3], *v;
-	const float *v0, *v1, *v2, *tc0, *tc1, *tc2;
+	float sdir[3], tdir[3], normal[3], *sv, *tv;
+	const float *v0, *v1, *v2, *tc0, *tc1, *tc2, *n;
 	float f, tangentcross[3], v10[3], v20[3], tc10[2], tc20[2];
 	const int *e;
 	// clear the vectors
-	if (svector3f)
-		memset(svector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
-	if (tvector3f)
-		memset(tvector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
-	if (normal3f)
-		memset(normal3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
+	memset(svector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
+	memset(tvector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
 	// process each vertex of each triangle and accumulate the results
 	for (tnum = 0, e = elements;tnum < numtriangles;tnum++, e += 3)
 	{
@@ -653,17 +676,6 @@ void Mod_BuildTextureVectorsAndNormals(int firstvertex, int numvertices, int num
 		tdir[1] = tc10[0] * v20[1] - tc20[0] * v10[1];
 		tdir[2] = tc10[0] * v20[2] - tc20[0] * v10[2];
 
-		// make the tangents completely perpendicular to the surface normal
-		// 12 multiply, 4 add, 6 subtract
-		f = DotProduct(sdir, normal);
-		sdir[0] -= f * normal[0];
-		sdir[1] -= f * normal[1];
-		sdir[2] -= f * normal[2];
-		f = DotProduct(tdir, normal);
-		tdir[0] -= f * normal[0];
-		tdir[1] -= f * normal[1];
-		tdir[2] -= f * normal[2];
-
 		// if texture is mapped the wrong way (counterclockwise), the tangents
 		// have to be flipped, this is detected by calculating a normal from the
 		// two tangents, and seeing if it is opposite the surface normal
@@ -679,62 +691,52 @@ void Mod_BuildTextureVectorsAndNormals(int firstvertex, int numvertices, int num
 		{
 			VectorNormalize(sdir);
 			VectorNormalize(tdir);
-			VectorNormalize(normal);
 		}
-		if (svector3f)
-			for (i = 0;i < 3;i++)
-				VectorAdd(svector3f + e[i]*3, sdir, svector3f + e[i]*3);
-		if (tvector3f)
-			for (i = 0;i < 3;i++)
-				VectorAdd(tvector3f + e[i]*3, tdir, tvector3f + e[i]*3);
-		if (normal3f)
-			for (i = 0;i < 3;i++)
-				VectorAdd(normal3f + e[i]*3, normal, normal3f + e[i]*3);
+		for (i = 0;i < 3;i++)
+		{
+			VectorAdd(svector3f + e[i]*3, sdir, svector3f + e[i]*3);
+			VectorAdd(tvector3f + e[i]*3, tdir, tvector3f + e[i]*3);
+		}
+	}
+	// make the tangents completely perpendicular to the surface normal, and
+	// then normalize them
+	// 16 assignments, 2 divide, 2 sqrt, 2 negates, 14 adds, 24 multiplies
+	for (i = 0, sv = svector3f + 3 * firstvertex, tv = tvector3f + 3 * firstvertex, n = normal3f + 3 * firstvertex;i < numvertices;i++, sv += 3, tv += 3, n += 3)
+	{
+		f = -DotProduct(sv, n);
+		VectorMA(sv, f, n, sv);
+		VectorNormalize(sv);
+		f = -DotProduct(tv, n);
+		VectorMA(tv, f, n, tv);
+		VectorNormalize(tv);
 	}
-	// now we could divide the vectors by the number of averaged values on
-	// each vertex...  but instead normalize them
-	// 4 assignments, 1 divide, 1 sqrt, 2 adds, 6 multiplies
-	if (svector3f)
-		for (i = 0, v = svector3f + 3 * firstvertex;i < numvertices;i++, v += 3)
-			VectorNormalize(v);
-	// 4 assignments, 1 divide, 1 sqrt, 2 adds, 6 multiplies
-	if (tvector3f)
-		for (i = 0, v = tvector3f + 3 * firstvertex;i < numvertices;i++, v += 3)
-			VectorNormalize(v);
-	// 4 assignments, 1 divide, 1 sqrt, 2 adds, 6 multiplies
-	if (normal3f)
-		for (i = 0, v = normal3f + 3 * firstvertex;i < numvertices;i++, v += 3)
-			VectorNormalize(v);
 }
 
-surfmesh_t *Mod_AllocSurfMesh(mempool_t *mempool, int numvertices, int numtriangles, qboolean lightmapoffsets, qboolean vertexcolors, qboolean neighbors)
+void Mod_AllocSurfMesh(mempool_t *mempool, int numvertices, int numtriangles, qboolean lightmapoffsets, qboolean vertexcolors, qboolean neighbors)
 {
-	surfmesh_t *mesh;
 	unsigned char *data;
-	mesh = (surfmesh_t *)Mem_Alloc(mempool, sizeof(surfmesh_t) + numvertices * (3 + 3 + 3 + 3 + 2 + 2 + (vertexcolors ? 4 : 0)) * sizeof(float) + numvertices * (lightmapoffsets ? 1 : 0) * sizeof(int) + numtriangles * (3 + (neighbors ? 3 : 0)) * sizeof(int));
-	mesh->num_vertices = numvertices;
-	mesh->num_triangles = numtriangles;
-	data = (unsigned char *)(mesh + 1);
-	if (mesh->num_vertices)
+	data = (unsigned char *)Mem_Alloc(mempool, numvertices * (3 + 3 + 3 + 3 + 2 + 2 + (vertexcolors ? 4 : 0)) * sizeof(float) + numvertices * (lightmapoffsets ? 1 : 0) * sizeof(int) + numtriangles * (3 + (neighbors ? 3 : 0)) * sizeof(int));
+	loadmodel->surfmesh.num_vertices = numvertices;
+	loadmodel->surfmesh.num_triangles = numtriangles;
+	if (loadmodel->surfmesh.num_vertices)
 	{
-		mesh->data_vertex3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
-		mesh->data_svector3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
-		mesh->data_tvector3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
-		mesh->data_normal3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
-		mesh->data_texcoordtexture2f = (float *)data, data += sizeof(float[2]) * mesh->num_vertices;
-		mesh->data_texcoordlightmap2f = (float *)data, data += sizeof(float[2]) * mesh->num_vertices;
+		loadmodel->surfmesh.data_vertex3f = (float *)data, data += sizeof(float[3]) * loadmodel->surfmesh.num_vertices;
+		loadmodel->surfmesh.data_svector3f = (float *)data, data += sizeof(float[3]) * loadmodel->surfmesh.num_vertices;
+		loadmodel->surfmesh.data_tvector3f = (float *)data, data += sizeof(float[3]) * loadmodel->surfmesh.num_vertices;
+		loadmodel->surfmesh.data_normal3f = (float *)data, data += sizeof(float[3]) * loadmodel->surfmesh.num_vertices;
+		loadmodel->surfmesh.data_texcoordtexture2f = (float *)data, data += sizeof(float[2]) * loadmodel->surfmesh.num_vertices;
+		loadmodel->surfmesh.data_texcoordlightmap2f = (float *)data, data += sizeof(float[2]) * loadmodel->surfmesh.num_vertices;
 		if (vertexcolors)
-			mesh->data_lightmapcolor4f = (float *)data, data += sizeof(float[4]) * mesh->num_vertices;
+			loadmodel->surfmesh.data_lightmapcolor4f = (float *)data, data += sizeof(float[4]) * loadmodel->surfmesh.num_vertices;
 		if (lightmapoffsets)
-			mesh->data_lightmapoffsets = (int *)data, data += sizeof(int) * mesh->num_vertices;
+			loadmodel->surfmesh.data_lightmapoffsets = (int *)data, data += sizeof(int) * loadmodel->surfmesh.num_vertices;
 	}
-	if (mesh->num_triangles)
+	if (loadmodel->surfmesh.num_triangles)
 	{
-		mesh->data_element3i = (int *)data, data += sizeof(int[3]) * mesh->num_triangles;
+		loadmodel->surfmesh.data_element3i = (int *)data, data += sizeof(int[3]) * loadmodel->surfmesh.num_triangles;
 		if (neighbors)
-			mesh->data_neighbor3i = (int *)data, data += sizeof(int[3]) * mesh->num_triangles;
+			loadmodel->surfmesh.data_neighbor3i = (int *)data, data += sizeof(int[3]) * loadmodel->surfmesh.num_triangles;
 	}
-	return mesh;
 }
 
 shadowmesh_t *Mod_ShadowMesh_Alloc(mempool_t *mempool, int maxverts, int maxtriangles, rtexture_t *map_diffuse, rtexture_t *map_specular, rtexture_t *map_normal, int light, int neighbors, int expandable)
@@ -902,7 +904,42 @@ shadowmesh_t *Mod_ShadowMesh_Begin(mempool_t *mempool, int maxverts, int maxtria
 	return Mod_ShadowMesh_Alloc(mempool, maxverts, maxtriangles, map_diffuse, map_specular, map_normal, light, neighbors, expandable);
 }
 
-shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh, int light, int neighbors)
+static void Mod_ShadowMesh_CreateVBOs(shadowmesh_t *mesh)
+{
+	if (!gl_support_arb_vertex_buffer_object)
+		return;
+
+	// element buffer is easy because it's just one array
+	if (mesh->numtriangles)
+		mesh->ebo = R_Mesh_CreateStaticBufferObject(GL_ELEMENT_ARRAY_BUFFER_ARB, mesh->element3i, mesh->numtriangles * sizeof(int[3]), "shadowmesh");
+
+	// vertex buffer is several arrays and we put them in the same buffer
+	//
+	// is this wise?  the texcoordtexture2f array is used with dynamic
+	// vertex/svector/tvector/normal when rendering animated models, on the
+	// other hand animated models don't use a lot of vertices anyway...
+	if (mesh->numverts)
+	{
+		size_t size;
+		unsigned char *mem;
+		size = 0;
+		mesh->vbooffset_vertex3f           = size;if (mesh->vertex3f          ) size += mesh->numverts * sizeof(float[3]);
+		mesh->vbooffset_svector3f          = size;if (mesh->svector3f         ) size += mesh->numverts * sizeof(float[3]);
+		mesh->vbooffset_tvector3f          = size;if (mesh->tvector3f         ) size += mesh->numverts * sizeof(float[3]);
+		mesh->vbooffset_normal3f           = size;if (mesh->normal3f          ) size += mesh->numverts * sizeof(float[3]);
+		mesh->vbooffset_texcoord2f         = size;if (mesh->texcoord2f        ) size += mesh->numverts * sizeof(float[2]);
+		mem = (unsigned char *)Mem_Alloc(tempmempool, size);
+		if (mesh->vertex3f          ) memcpy(mem + mesh->vbooffset_vertex3f          , mesh->vertex3f          , mesh->numverts * sizeof(float[3]));
+		if (mesh->svector3f         ) memcpy(mem + mesh->vbooffset_svector3f         , mesh->svector3f         , mesh->numverts * sizeof(float[3]));
+		if (mesh->tvector3f         ) memcpy(mem + mesh->vbooffset_tvector3f         , mesh->tvector3f         , mesh->numverts * sizeof(float[3]));
+		if (mesh->normal3f          ) memcpy(mem + mesh->vbooffset_normal3f          , mesh->normal3f          , mesh->numverts * sizeof(float[3]));
+		if (mesh->texcoord2f        ) memcpy(mem + mesh->vbooffset_texcoord2f        , mesh->texcoord2f        , mesh->numverts * sizeof(float[2]));
+		mesh->vbo = R_Mesh_CreateStaticBufferObject(GL_ARRAY_BUFFER_ARB, mem, size, "shadowmesh");
+		Mem_Free(mem);
+	}
+}
+
+shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh, qboolean light, qboolean neighbors, qboolean createvbo)
 {
 	shadowmesh_t *mesh, *newmesh, *nextmesh;
 	// reallocate meshs to conserve space
@@ -914,6 +951,8 @@ shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh,
 			newmesh = Mod_ShadowMesh_ReAlloc(mempool, mesh, light, neighbors);
 			newmesh->next = firstmesh;
 			firstmesh = newmesh;
+			if (createvbo)
+				Mod_ShadowMesh_CreateVBOs(newmesh);
 		}
 		Mem_Free(mesh);
 	}
@@ -974,135 +1013,15 @@ void Mod_ShadowMesh_Free(shadowmesh_t *mesh)
 	shadowmesh_t *nextmesh;
 	for (;mesh;mesh = nextmesh)
 	{
+		if (mesh->ebo)
+			R_Mesh_DestroyBufferObject(mesh->ebo);
+		if (mesh->vbo)
+			R_Mesh_DestroyBufferObject(mesh->vbo);
 		nextmesh = mesh->next;
 		Mem_Free(mesh);
 	}
 }
 
-static rtexture_t *GL_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags)
-{
-	int i;
-	for (i = 0;i < width*height;i++)
-		if (((unsigned char *)&palette[in[i]])[3] > 0)
-			return R_LoadTexture2D (loadmodel->texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
-	return NULL;
-}
-
-int Mod_LoadSkinFrame(skinframe_t *skinframe, const char *basename, int textureflags, int loadpantsandshirt, int loadglowtexture)
-{
-	imageskin_t s;
-	memset(skinframe, 0, sizeof(*skinframe));
-	if (cls.state == ca_dedicated)
-		return false;
-	if (!image_loadskin(&s, basename))
-		return false;
-	skinframe->base = R_LoadTexture2D (loadmodel->texturepool, basename, s.basepixels_width, s.basepixels_height, s.basepixels, TEXTYPE_RGBA, textureflags, NULL);
-	if (s.nmappixels != NULL)
-		skinframe->nmap = R_LoadTexture2D (loadmodel->texturepool, va("%s_nmap", basename), s.nmappixels_width, s.nmappixels_height, s.nmappixels, TEXTYPE_RGBA, textureflags, NULL);
-	if (s.glosspixels != NULL)
-		skinframe->gloss = R_LoadTexture2D (loadmodel->texturepool, va("%s_gloss", basename), s.glosspixels_width, s.glosspixels_height, s.glosspixels, TEXTYPE_RGBA, textureflags, NULL);
-	if (s.glowpixels != NULL && loadglowtexture)
-		skinframe->glow = R_LoadTexture2D (loadmodel->texturepool, va("%s_glow", basename), s.glowpixels_width, s.glowpixels_height, s.glowpixels, TEXTYPE_RGBA, textureflags, NULL);
-	if (s.maskpixels != NULL)
-		skinframe->fog = R_LoadTexture2D (loadmodel->texturepool, va("%s_mask", basename), s.maskpixels_width, s.maskpixels_height, s.maskpixels, TEXTYPE_RGBA, textureflags, NULL);
-	if (loadpantsandshirt)
-	{
-		if (s.pantspixels != NULL)
-			skinframe->pants = R_LoadTexture2D (loadmodel->texturepool, va("%s_pants", basename), s.pantspixels_width, s.pantspixels_height, s.pantspixels, TEXTYPE_RGBA, textureflags, NULL);
-		if (s.shirtpixels != NULL)
-			skinframe->shirt = R_LoadTexture2D (loadmodel->texturepool, va("%s_shirt", basename), s.shirtpixels_width, s.shirtpixels_height, s.shirtpixels, TEXTYPE_RGBA, textureflags, NULL);
-	}
-	if (!skinframe->base)
-		skinframe->base = r_texture_notexture;
-	if (!skinframe->nmap)
-		skinframe->nmap = r_texture_blanknormalmap;
-	image_freeskin(&s);
-	return true;
-}
-
-int Mod_LoadSkinFrame_Internal(skinframe_t *skinframe, const char *basename, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height, int bitsperpixel, const unsigned int *palette, const unsigned int *alphapalette)
-{
-	int i;
-	unsigned char *temp1, *temp2;
-	memset(skinframe, 0, sizeof(*skinframe));
-	if (cls.state == ca_dedicated)
-		return false;
-	if (!skindata)
-		return false;
-	if (bitsperpixel == 32)
-	{
-		if (r_shadow_bumpscale_basetexture.value > 0)
-		{
-			temp1 = (unsigned char *)Mem_Alloc(loadmodel->mempool, width * height * 8);
-			temp2 = temp1 + width * height * 4;
-			Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
-			skinframe->nmap = R_LoadTexture2D(loadmodel->texturepool, va("%s_nmap", basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
-			Mem_Free(temp1);
-		}
-		skinframe->base = skinframe->merged = R_LoadTexture2D(loadmodel->texturepool, basename, width, height, skindata, TEXTYPE_RGBA, textureflags, NULL);
-		if (textureflags & TEXF_ALPHA)
-		{
-			for (i = 3;i < width * height * 4;i += 4)
-				if (skindata[i] < 255)
-					break;
-			if (i < width * height * 4)
-			{
-				unsigned char *fogpixels = Mem_Alloc(loadmodel->mempool, width * height * 4);
-				memcpy(fogpixels, skindata, width * height * 4);
-				for (i = 0;i < width * height * 4;i += 4)
-					fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
-				skinframe->fog = R_LoadTexture2D(loadmodel->texturepool, va("%s_fog", basename), width, height, fogpixels, TEXTYPE_RGBA, textureflags, NULL);
-				Mem_Free(fogpixels);
-			}
-		}
-	}
-	else if (bitsperpixel == 8)
-	{
-		if (r_shadow_bumpscale_basetexture.value > 0)
-		{
-			temp1 = (unsigned char *)Mem_Alloc(loadmodel->mempool, width * height * 8);
-			temp2 = temp1 + width * height * 4;
-			if (bitsperpixel == 32)
-				Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
-			else
-			{
-				// use either a custom palette or the quake palette
-				Image_Copy8bitRGBA(skindata, temp1, width * height, palette ? palette : palette_complete);
-				Image_HeightmapToNormalmap(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
-			}
-			skinframe->nmap = R_LoadTexture2D(loadmodel->texturepool, va("%s_nmap", basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
-			Mem_Free(temp1);
-		}
-		// use either a custom palette, or the quake palette
-		skinframe->base = skinframe->merged = GL_TextureForSkinLayer(skindata, width, height, va("%s_merged", basename), palette ? palette : (loadglowtexture ? palette_nofullbrights : ((textureflags & TEXF_ALPHA) ? palette_transparent : palette_complete)), textureflags); // all
-		if (!palette && loadglowtexture)
-			skinframe->glow = GL_TextureForSkinLayer(skindata, width, height, va("%s_glow", basename), palette_onlyfullbrights, textureflags); // glow
-		if (!palette && loadpantsandshirt)
-		{
-			skinframe->pants = GL_TextureForSkinLayer(skindata, width, height, va("%s_pants", basename), palette_pantsaswhite, textureflags); // pants
-			skinframe->shirt = GL_TextureForSkinLayer(skindata, width, height, va("%s_shirt", basename), palette_shirtaswhite, textureflags); // shirt
-		}
-		if (skinframe->pants || skinframe->shirt)
-			skinframe->base = GL_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", basename),loadglowtexture ? palette_nocolormapnofullbrights : palette_nocolormap, textureflags); // no special colors
-		if (textureflags & TEXF_ALPHA)
-		{
-			// if not using a custom alphapalette, use the quake one
-			if (!alphapalette)
-				alphapalette = palette_alpha;
-			for (i = 0;i < width * height;i++)
-				if (((unsigned char *)alphapalette)[skindata[i]*4+3] < 255)
-					break;
-			if (i < width * height)
-				skinframe->fog = GL_TextureForSkinLayer(skindata, width, height, va("%s_fog", basename), alphapalette, textureflags); // fog mask
-		}
-	}
-	else
-		return false;
-	if (!skinframe->nmap)
-		skinframe->nmap = r_texture_blanknormalmap;
-	return true;
-}
-
 void Mod_GetTerrainVertex3fTexCoord2fFromRGBA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
 {
 	float v[3], tc[3];
@@ -1349,3 +1268,63 @@ int Mod_RemoveDegenerateTriangles(int numtriangles, const int *inelement3i, int
 	return outtriangles;
 }
 
+void Mod_VertexRangeFromElements(int numelements, const int *elements, int *firstvertexpointer, int *lastvertexpointer)
+{
+	int i, e;
+	int firstvertex, lastvertex;
+	if (numelements > 0 && elements)
+	{
+		firstvertex = lastvertex = elements[0];
+		for (i = 1;i < numelements;i++)
+		{
+			e = elements[i];
+			firstvertex = min(firstvertex, e);
+			lastvertex = max(lastvertex, e);
+		}
+	}
+	else
+		firstvertex = lastvertex = 0;
+	if (firstvertexpointer)
+		*firstvertexpointer = firstvertex;
+	if (lastvertexpointer)
+		*lastvertexpointer = lastvertex;
+}
+
+static void Mod_BuildVBOs(void)
+{
+	if (!gl_support_arb_vertex_buffer_object)
+		return;
+
+	// element buffer is easy because it's just one array
+	if (loadmodel->surfmesh.num_triangles)
+		loadmodel->surfmesh.ebo = R_Mesh_CreateStaticBufferObject(GL_ELEMENT_ARRAY_BUFFER_ARB, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles * sizeof(int[3]), loadmodel->name);
+
+	// vertex buffer is several arrays and we put them in the same buffer
+	//
+	// is this wise?  the texcoordtexture2f array is used with dynamic
+	// vertex/svector/tvector/normal when rendering animated models, on the
+	// other hand animated models don't use a lot of vertices anyway...
+	if (loadmodel->surfmesh.num_vertices)
+	{
+		size_t size;
+		unsigned char *mem;
+		size = 0;
+		loadmodel->surfmesh.vbooffset_vertex3f           = size;if (loadmodel->surfmesh.data_vertex3f          ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+		loadmodel->surfmesh.vbooffset_svector3f          = size;if (loadmodel->surfmesh.data_svector3f         ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+		loadmodel->surfmesh.vbooffset_tvector3f          = size;if (loadmodel->surfmesh.data_tvector3f         ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+		loadmodel->surfmesh.vbooffset_normal3f           = size;if (loadmodel->surfmesh.data_normal3f          ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+		loadmodel->surfmesh.vbooffset_texcoordtexture2f  = size;if (loadmodel->surfmesh.data_texcoordtexture2f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+		loadmodel->surfmesh.vbooffset_texcoordlightmap2f = size;if (loadmodel->surfmesh.data_texcoordlightmap2f) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+		loadmodel->surfmesh.vbooffset_lightmapcolor4f    = size;if (loadmodel->surfmesh.data_lightmapcolor4f   ) size += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
+		mem = (unsigned char *)Mem_Alloc(tempmempool, size);
+		if (loadmodel->surfmesh.data_vertex3f          ) memcpy(mem + loadmodel->surfmesh.vbooffset_vertex3f          , loadmodel->surfmesh.data_vertex3f          , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+		if (loadmodel->surfmesh.data_svector3f         ) memcpy(mem + loadmodel->surfmesh.vbooffset_svector3f         , loadmodel->surfmesh.data_svector3f         , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+		if (loadmodel->surfmesh.data_tvector3f         ) memcpy(mem + loadmodel->surfmesh.vbooffset_tvector3f         , loadmodel->surfmesh.data_tvector3f         , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+		if (loadmodel->surfmesh.data_normal3f          ) memcpy(mem + loadmodel->surfmesh.vbooffset_normal3f          , loadmodel->surfmesh.data_normal3f          , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+		if (loadmodel->surfmesh.data_texcoordtexture2f ) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordtexture2f , loadmodel->surfmesh.data_texcoordtexture2f , loadmodel->surfmesh.num_vertices * sizeof(float[2]));
+		if (loadmodel->surfmesh.data_texcoordlightmap2f) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordlightmap2f, loadmodel->surfmesh.data_texcoordlightmap2f, loadmodel->surfmesh.num_vertices * sizeof(float[2]));
+		if (loadmodel->surfmesh.data_lightmapcolor4f   ) memcpy(mem + loadmodel->surfmesh.vbooffset_lightmapcolor4f   , loadmodel->surfmesh.data_lightmapcolor4f   , loadmodel->surfmesh.num_vertices * sizeof(float[4]));
+		loadmodel->surfmesh.vbo = R_Mesh_CreateStaticBufferObject(GL_ARRAY_BUFFER_ARB, mem, size, loadmodel->name);
+		Mem_Free(mem);
+	}
+}