X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=68554e0dfc69f1d81c96494012fd52bc079a68fb;hb=ff2c00350c699772ab7406d5621115a2e8c1d19e;hp=430de3fbbc06a06e607ead60a857e8cdbd325480;hpb=f166f21fa69e9f10fc92217207fa51693dc1b411;p=xonotic%2Fdarkplaces.git

diff --git a/model_brush.c b/model_brush.c
index 430de3fb..68554e0d 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -74,8 +74,6 @@ static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
 	if (model == NULL)
 		return NULL;
 
-	Mod_CheckLoaded(model);
-
 	// LordHavoc: modified to start at first clip node,
 	// in other words: first node of the (sub)model
 	node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
@@ -104,6 +102,48 @@ static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p,
 		memset(out, 0, outsize);
 }
 
+static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
+{
+	int numclusters = 0, side, nodestackindex = 0;
+	mnode_t *node, *nodestack[1024];
+	if (!model->brush.num_pvsclusters)
+		return -1;
+	node = model->brush.data_nodes;
+	for (;;)
+	{
+		if (node->plane)
+		{
+			// node - recurse down the BSP tree
+			side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+			if (side < 2)
+			{
+				// box is on one side of plane, take that path
+				node = node->children[side];
+			}
+			else
+			{
+				// box crosses plane, take one path and remember the other
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+			}
+		}
+		else
+		{
+			// leaf - check cluster bit
+			if (numclusters < maxclusters)
+				clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
+			numclusters++;
+			// try another path we didn't take earlier
+			if (nodestackindex == 0)
+				break;
+			node = nodestack[--nodestackindex];
+		}
+	}
+	// return number of clusters found (even if more than the maxclusters)
+	return numclusters;
+}
+
 static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
 {
 	int clusterindex, side, nodestackindex = 0;
@@ -429,7 +469,7 @@ int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
 	return CONTENTS_EMPTY;
 }
 
-typedef struct
+typedef struct RecursiveHullCheckTraceInfo_s
 {
 	// the hull we're tracing through
 	const hull_t *hull;
@@ -1049,7 +1089,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		loadmodel->num_textures = 2;
 	}
 
-	loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
+	loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
 
 	// fill out all slots with notexture
 	for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++)
@@ -1141,7 +1181,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		}
 		else
 		{
-			if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', true))
+			if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true))
 			{
 				// did not find external texture, load it from the bsp or wad3
 				if (loadmodel->brush.ishlbsp)
@@ -1160,7 +1200,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 						tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
 						if (Image_CheckAlpha(pixels, image_width * image_height, true))
 						{
-							fogpixels = Mem_Alloc(tempmempool, image_width * image_height * 4);
+							fogpixels = (qbyte *)Mem_Alloc(tempmempool, image_width * image_height * 4);
 							for (j = 0;j < image_width * image_height * 4;j += 4)
 							{
 								fogpixels[j + 0] = 255;
@@ -1176,7 +1216,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 						Mem_Free(freepixels);
 				}
 				else if (mtdata) // texture included
-					Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
+					Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
 			}
 		}
 		if (tx->skin.base == NULL)
@@ -1333,13 +1373,13 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 	loadmodel->brushq1.lightdata = NULL;
 	if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
 	{
-		loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
+		loadmodel->brushq1.lightdata = (qbyte *)Mem_Alloc(loadmodel->mempool, l->filelen);
 		for (i=0; i<l->filelen; i++)
 			loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
 	}
 	else if (loadmodel->brush.ismcbsp)
 	{
-		loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
+		loadmodel->brushq1.lightdata = (qbyte *)Mem_Alloc(loadmodel->mempool, l->filelen);
 		memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
 	}
 	else // LordHavoc: bsp version 29 (normal white lighting)
@@ -1357,7 +1397,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 				if (i == 1)
 				{
 					Con_DPrintf("loaded %s\n", litfilename);
-					loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, fs_filesize - 8);
+					loadmodel->brushq1.lightdata = (qbyte *)Mem_Alloc(loadmodel->mempool, fs_filesize - 8);
 					memcpy(loadmodel->brushq1.lightdata, data + 8, fs_filesize - 8);
 					Mem_Free(data);
 					return;
@@ -1380,7 +1420,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 		// LordHavoc: oh well, expand the white lighting data
 		if (!l->filelen)
 			return;
-		loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen*3);
+		loadmodel->brushq1.lightdata = (qbyte *)Mem_Alloc(loadmodel->mempool, l->filelen*3);
 		in = loadmodel->brushq1.lightdata + l->filelen*2; // place the file at the end, so it will not be overwritten until the very last write
 		out = loadmodel->brushq1.lightdata;
 		memcpy(in, mod_base + l->fileofs, l->filelen);
@@ -1420,7 +1460,7 @@ static void Mod_Q1BSP_LoadLightList(void)
 			s++;
 			numlights++;
 		}
-		loadmodel->brushq1.lights = Mem_Alloc(loadmodel->mempool, numlights * sizeof(mlight_t));
+		loadmodel->brushq1.lights = (mlight_t *)Mem_Alloc(loadmodel->mempool, numlights * sizeof(mlight_t));
 		s = lightsstring;
 		n = 0;
 		while (*s && n < numlights)
@@ -1463,7 +1503,7 @@ static void Mod_Q1BSP_LoadVisibility(lump_t *l)
 	if (!l->filelen)
 		return;
 	loadmodel->brushq1.num_compressedpvs = l->filelen;
-	loadmodel->brushq1.data_compressedpvs = Mem_Alloc(loadmodel->mempool, l->filelen);
+	loadmodel->brushq1.data_compressedpvs = (qbyte *)Mem_Alloc(loadmodel->mempool, l->filelen);
 	memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen);
 }
 
@@ -1532,7 +1572,7 @@ static void Mod_Q1BSP_LoadEntities(lump_t *l)
 	loadmodel->brush.entities = NULL;
 	if (!l->filelen)
 		return;
-	loadmodel->brush.entities = Mem_Alloc(loadmodel->mempool, l->filelen);
+	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
 	memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
 	if (loadmodel->brush.ishlbsp)
 		Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
@@ -1545,11 +1585,11 @@ static void Mod_Q1BSP_LoadVertexes(lump_t *l)
 	mvertex_t	*out;
 	int			i, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dvertex_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadVertexes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	out = (mvertex_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brushq1.vertexes = out;
 	loadmodel->brushq1.numvertexes = count;
@@ -1562,35 +1602,63 @@ static void Mod_Q1BSP_LoadVertexes(lump_t *l)
 	}
 }
 
-static void Mod_Q1BSP_LoadSubmodels(lump_t *l)
+// The following two functions should be removed and MSG_* or SZ_* function sets adjusted so they
+// can be used for this
+// REMOVEME
+int SB_ReadInt (qbyte **buffer)
+{
+	int	i;
+	i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]);
+	(*buffer) += 4;
+	return i;
+}
+
+// REMOVEME
+float SB_ReadFloat (qbyte **buffer)
+{
+	union
+	{
+		int		i;
+		float	f;
+	} u;
+
+	u.i = SB_ReadInt (buffer);
+	return u.f;
+}
+
+static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo)
 {
-	dmodel_t	*in;
+	qbyte		*index;
 	dmodel_t	*out;
 	int			i, j, count;
 
-	in = (void *)(mod_base + l->fileofs);
-	if (l->filelen % sizeof(*in))
-		Host_Error("Mod_Q1BSP_LoadSubmodels: funny lump size in %s",loadmodel->name);
-	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	index = (qbyte *)(mod_base + l->fileofs);
+	if (l->filelen % (48+4*hullinfo->filehulls))
+		Host_Error ("Mod_Q1BSP_LoadSubmodels: funny lump size in %s", loadmodel->name);
+
+	count = l->filelen / (48+4*hullinfo->filehulls);
+	out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brushq1.submodels = out;
 	loadmodel->brush.numsubmodels = count;
 
-	for ( i=0 ; i<count ; i++, in++, out++)
-	{
-		for (j=0 ; j<3 ; j++)
-		{
-			// spread the mins / maxs by a pixel
-			out->mins[j] = LittleFloat(in->mins[j]) - 1;
-			out->maxs[j] = LittleFloat(in->maxs[j]) + 1;
-			out->origin[j] = LittleFloat(in->origin[j]);
-		}
-		for (j=0 ; j<MAX_MAP_HULLS ; j++)
-			out->headnode[j] = LittleLong(in->headnode[j]);
-		out->visleafs = LittleLong(in->visleafs);
-		out->firstface = LittleLong(in->firstface);
-		out->numfaces = LittleLong(in->numfaces);
+	for (i = 0; i < count; i++, out++)
+	{
+	// spread out the mins / maxs by a pixel
+		out->mins[0] = SB_ReadFloat (&index) - 1;
+		out->mins[1] = SB_ReadFloat (&index) - 1;
+		out->mins[2] = SB_ReadFloat (&index) - 1;
+		out->maxs[0] = SB_ReadFloat (&index) + 1;
+		out->maxs[1] = SB_ReadFloat (&index) + 1;
+		out->maxs[2] = SB_ReadFloat (&index) + 1;
+		out->origin[0] = SB_ReadFloat (&index);
+		out->origin[1] = SB_ReadFloat (&index);
+		out->origin[2] = SB_ReadFloat (&index);
+		for (j = 0; j < hullinfo->filehulls; j++)
+			out->headnode[j] = SB_ReadInt (&index);
+		out->visleafs = SB_ReadInt (&index);
+		out->firstface = SB_ReadInt (&index);
+		out->numfaces = SB_ReadInt (&index);
 	}
 }
 
@@ -1600,11 +1668,11 @@ static void Mod_Q1BSP_LoadEdges(lump_t *l)
 	medge_t *out;
 	int 	i, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dedge_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadEdges: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (medge_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq1.edges = out;
 	loadmodel->brushq1.numedges = count;
@@ -1622,11 +1690,11 @@ static void Mod_Q1BSP_LoadTexinfo(lump_t *l)
 	mtexinfo_t *out;
 	int i, j, k, count, miptex;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (texinfo_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadTexinfo: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq1.texinfo = out;
 	loadmodel->brushq1.numtexinfo = count;
@@ -1823,18 +1891,18 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris;
 	float texmins[2], texmaxs[2], val;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dface_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	loadmodel->data_surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
-	loadmodel->data_surfaces_lightmapinfo = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
+	loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
+	loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
 
 	loadmodel->num_surfaces = count;
 
 	totalverts = 0;
 	totaltris = 0;
-	for (surfacenum = 0, in = (void *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
+	for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
 	{
 		numedges = LittleShort(in->numedges);
 		totalverts += numedges;
@@ -1844,12 +1912,12 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	// TODO: split up into multiple meshes as needed to avoid exceeding 65536
 	// vertex limit
 	loadmodel->nummeshes = 1;
-	loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *));
-	loadmodel->meshlist[0] = Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, true, false, false);
+	loadmodel->meshlist = (surfmesh_t **)Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *));
+	loadmodel->meshlist[0] = Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false);
 
 	totalverts = 0;
 	totaltris = 0;
-	for (surfacenum = 0, in = (void *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
+	for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
 	{
 		surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum;
 
@@ -1894,8 +1962,6 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			t = DotProduct(((surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
 			(surface->groupmesh->data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 0] = s / surface->texture->width;
 			(surface->groupmesh->data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 1] = t / surface->texture->height;
-			(surface->groupmesh->data_texcoorddetail2f + 2 * surface->num_firstvertex)[i * 2 + 0] = s * (1.0f / 16.0f);
-			(surface->groupmesh->data_texcoorddetail2f + 2 * surface->num_firstvertex)[i * 2 + 1] = t * (1.0f / 16.0f);
 			(surface->groupmesh->data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = 0;
 			(surface->groupmesh->data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = 0;
 			(surface->groupmesh->data_lightmapoffsets + surface->num_firstvertex)[i] = 0;
@@ -1949,7 +2015,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			// give non-lightmapped water a 1x white lightmap
 			if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
 			{
-				surface->lightmapinfo->samples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+				surface->lightmapinfo->samples = (qbyte *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
 				surface->lightmapinfo->styles[0] = 0;
 				memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
 			}
@@ -1967,7 +2033,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			if (ssize > 256 || tsize > 256)
 				Host_Error("Bad surface extents");
 			// stainmap for permanent marks on walls
-			surface->lightmapinfo->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+			surface->lightmapinfo->stainsamples = (qbyte *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
 			// clear to white
 			memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
 
@@ -2018,11 +2084,11 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l)
 	dnode_t		*in;
 	mnode_t 	*out;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dnode_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brush.data_nodes = out;
 	loadmodel->brush.num_nodes = count;
@@ -2060,18 +2126,18 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l)
 	mleaf_t *out;
 	int i, j, count, p;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dleaf_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brush.data_leafs = out;
 	loadmodel->brush.num_leafs = count;
 	// get visleafs from the submodel data
 	loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
 	loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
-	loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
+	loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
 	memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
 
 	for ( i=0 ; i<count ; i++, in++, out++)
@@ -2116,116 +2182,34 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l)
 	}
 }
 
-static void Mod_Q1BSP_LoadClipnodes(lump_t *l)
+static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 {
 	dclipnode_t *in, *out;
 	int			i, count;
 	hull_t		*hull;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dclipnode_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brushq1.clipnodes = out;
 	loadmodel->brushq1.numclipnodes = count;
 
-	if (loadmodel->brush.ismcbsp)
-	{
-		hull = &loadmodel->brushq1.hulls[1];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -12;
-		hull->clip_mins[1] = -12;
-		hull->clip_mins[2] = -24;
-		hull->clip_maxs[0] = 12;
-		hull->clip_maxs[1] = 12;
-		hull->clip_maxs[2] = 32;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-
-		hull = &loadmodel->brushq1.hulls[2];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -12;
-		hull->clip_mins[1] = -12;
-		hull->clip_mins[2] = -24;
-		hull->clip_maxs[0] = 12;
-		hull->clip_maxs[1] = 12;
-		hull->clip_maxs[2] = 16;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-	}
-	else if (loadmodel->brush.ishlbsp)
-	{
-		hull = &loadmodel->brushq1.hulls[1];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -16;
-		hull->clip_mins[1] = -16;
-		hull->clip_mins[2] = -36;
-		hull->clip_maxs[0] = 16;
-		hull->clip_maxs[1] = 16;
-		hull->clip_maxs[2] = 36;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-
-		hull = &loadmodel->brushq1.hulls[2];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -32;
-		hull->clip_mins[1] = -32;
-		hull->clip_mins[2] = -32;
-		hull->clip_maxs[0] = 32;
-		hull->clip_maxs[1] = 32;
-		hull->clip_maxs[2] = 32;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-
-		hull = &loadmodel->brushq1.hulls[3];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -16;
-		hull->clip_mins[1] = -16;
-		hull->clip_mins[2] = -18;
-		hull->clip_maxs[0] = 16;
-		hull->clip_maxs[1] = 16;
-		hull->clip_maxs[2] = 18;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-	}
-	else
+	for (i = 1; i < hullinfo->numhulls; i++)
 	{
-		hull = &loadmodel->brushq1.hulls[1];
-		hull->clipnodes = out;
-		hull->firstclipnode = 0;
-		hull->lastclipnode = count-1;
-		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -16;
-		hull->clip_mins[1] = -16;
-		hull->clip_mins[2] = -24;
-		hull->clip_maxs[0] = 16;
-		hull->clip_maxs[1] = 16;
-		hull->clip_maxs[2] = 32;
-		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
-
-		hull = &loadmodel->brushq1.hulls[2];
+		hull = &loadmodel->brushq1.hulls[i];
 		hull->clipnodes = out;
 		hull->firstclipnode = 0;
 		hull->lastclipnode = count-1;
 		hull->planes = loadmodel->brush.data_planes;
-		hull->clip_mins[0] = -32;
-		hull->clip_mins[1] = -32;
-		hull->clip_mins[2] = -24;
-		hull->clip_maxs[0] = 32;
-		hull->clip_maxs[1] = 32;
-		hull->clip_maxs[2] = 64;
+		hull->clip_mins[0] = hullinfo->hullsizes[i][0][0];
+		hull->clip_mins[1] = hullinfo->hullsizes[i][0][1];
+		hull->clip_mins[2] = hullinfo->hullsizes[i][0][2];
+		hull->clip_maxs[0] = hullinfo->hullsizes[i][1][0];
+		hull->clip_maxs[1] = hullinfo->hullsizes[i][1][1];
+		hull->clip_maxs[2] = hullinfo->hullsizes[i][1][2];
 		VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
 	}
 
@@ -2250,7 +2234,7 @@ static void Mod_Q1BSP_MakeHull0(void)
 	hull = &loadmodel->brushq1.hulls[0];
 
 	in = loadmodel->brush.data_nodes;
-	out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
+	out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
 
 	hull->clipnodes = out;
 	hull->firstclipnode = 0;
@@ -2270,11 +2254,11 @@ static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
 	int i, j;
 	short *in;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (short *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
 	loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
-	loadmodel->brush.data_leafsurfaces = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
+	loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
 
 	for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
 	{
@@ -2290,11 +2274,11 @@ static void Mod_Q1BSP_LoadSurfedges(lump_t *l)
 	int		i;
 	int		*in;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (int *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name);
 	loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in);
-	loadmodel->brushq1.surfedges = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
+	loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
 
 	for (i = 0;i < loadmodel->brushq1.numsurfedges;i++)
 		loadmodel->brushq1.surfedges[i] = LittleLong(in[i]);
@@ -2307,12 +2291,12 @@ static void Mod_Q1BSP_LoadPlanes(lump_t *l)
 	mplane_t	*out;
 	dplane_t 	*in;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (dplane_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
 
 	loadmodel->brush.num_planes = l->filelen / sizeof(*in);
-	loadmodel->brush.data_planes = out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
+	loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
 
 	for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
 	{
@@ -2444,7 +2428,7 @@ AllocPortal
 static portal_t *AllocPortal(void)
 {
 	portal_t *p;
-	p = Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
+	p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
 	p->chain = portalchain;
 	portalchain = p;
 	return p;
@@ -2529,9 +2513,9 @@ static void Mod_Q1BSP_FinalizePortals(void)
 		}
 		p = p->chain;
 	}
-	loadmodel->brush.data_portals = Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
+	loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
 	loadmodel->brush.num_portals = numportals;
-	loadmodel->brush.data_portalpoints = (void *)((qbyte *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
+	loadmodel->brush.data_portalpoints = (mvertex_t *)((qbyte *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
 	loadmodel->brush.num_portalpoints = numpoints;
 	// clear all leaf portal chains
 	for (i = 0;i < loadmodel->brush.num_leafs;i++)
@@ -2642,7 +2626,7 @@ static void RemovePortalFromNodes(portal_t *portal)
 		portalpointer = (void **) &node->portals;
 		while (1)
 		{
-			t = *portalpointer;
+			t = (portal_t *)*portalpointer;
 			if (!t)
 				Host_Error("RemovePortalFromNodes: portal not in leaf");
 
@@ -2834,10 +2818,10 @@ static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *mod
 	}
 	if (!totalcount)
 		return;
-	model->brushq1.light_style = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(qbyte));
-	model->brushq1.light_stylevalue = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
-	model->brushq1.light_styleupdatechains = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
-	model->brushq1.light_styleupdatechainsbuffer = Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
+	model->brushq1.light_style = (qbyte *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(qbyte));
+	model->brushq1.light_stylevalue = (int *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
+	model->brushq1.light_styleupdatechains = (msurface_t ***)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
+	model->brushq1.light_styleupdatechainsbuffer = (msurface_t **)Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
 	model->brushq1.light_styles = 0;
 	for (i = 0;i < 255;i++)
 		if (stylecounts[i])
@@ -2869,7 +2853,6 @@ static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *mod
 static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
 {
 	mnode_t *node;
-	Mod_CheckLoaded(model);
 	node = model->brush.data_nodes;
 	while (node->plane)
 		node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
@@ -2972,18 +2955,50 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	float dist, modelyawradius, modelradius, *vec;
 	msurface_t *surface;
 	int numshadowmeshtriangles;
+	dheader_t _header;
+	hullinfo_t hullinfo;
 
 	mod->type = mod_brushq1;
 
-	if (!memcmp(buffer, "MCBSP", 5))
+	if (!memcmp (buffer, "MCBSPpad", 8))
 	{
-		header = (dheader_t *)((unsigned char*)buffer + 5);
+		qbyte	*index;
 
-		i = LittleLong(header->version);
-		if (i != MCBSPVERSION)
-			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(MCBSP %i should be %i", mod->name, i, MCBSPVERSION);
 		mod->brush.ismcbsp = true;
 		mod->brush.ishlbsp = false;
+
+		mod_base = (qbyte*)buffer;
+
+		index = mod_base;
+		index += 8;
+		i = SB_ReadInt (&index);
+		if (i != MCBSPVERSION)
+			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
+
+	// read hull info
+		hullinfo.numhulls = LittleLong(*(int*)index); index += 4;
+		hullinfo.filehulls = hullinfo.numhulls;
+		VectorClear (hullinfo.hullsizes[0][0]);
+		VectorClear (hullinfo.hullsizes[0][1]);
+		for (i = 1; i < hullinfo.numhulls; i++)
+		{
+			hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
+			hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
+			hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
+			hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
+			hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
+			hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
+		}
+
+	// read lumps
+		_header.version = 0;
+		for (i = 0; i < HEADER_LUMPS; i++)
+		{
+			_header.lumps[i].fileofs = SB_ReadInt (&index);
+			_header.lumps[i].filelen = SB_ReadInt (&index);
+		}
+
+		header = &_header;
 	}
 	else
 	{
@@ -2993,6 +3008,39 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		if (i != BSPVERSION && i != 30)
 			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
 		mod->brush.ishlbsp = i == 30;
+		mod->brush.ismcbsp = false;
+
+	// fill in hull info
+		VectorClear (hullinfo.hullsizes[0][0]);
+		VectorClear (hullinfo.hullsizes[0][1]);
+		if (mod->brush.ishlbsp)
+		{
+			hullinfo.numhulls = 4;
+			hullinfo.filehulls = 4;
+			VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
+			VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
+			VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
+			VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
+			VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
+			VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
+		}
+		else
+		{
+			hullinfo.numhulls = 3;
+			hullinfo.filehulls = 4;
+			VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
+			VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
+			VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
+			VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
+		}
+
+	// read lumps
+		mod_base = (qbyte*)buffer;
+		for (i = 0; i < HEADER_LUMPS; i++)
+		{
+			header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+			header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+		}
 	}
 
 	mod->soundfromcenter = true;
@@ -3004,6 +3052,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
 	mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
 	mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
+	mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
 	mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
 	mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
 	mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
@@ -3016,16 +3065,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
 	}
 
-// swap all the lumps
-	mod_base = (qbyte *)header;
-
-	header->version = LittleLong(header->version);
-	for (i = 0;i < HEADER_LUMPS;i++)
-	{
-		header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
-		header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
-	}
-
 // load into heap
 
 	// store which lightmap format to use
@@ -3043,10 +3082,10 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_Q1BSP_LoadLeaffaces(&header->lumps[LUMP_MARKSURFACES]);
 	Mod_Q1BSP_LoadVisibility(&header->lumps[LUMP_VISIBILITY]);
 	// load submodels before leafs because they contain the number of vis leafs
-	Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS]);
+	Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS], &hullinfo);
 	Mod_Q1BSP_LoadLeafs(&header->lumps[LUMP_LEAFS]);
 	Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]);
-	Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES]);
+	Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES], &hullinfo);
 
 	if (!mod->brushq1.lightdata)
 		mod->brush.LightPoint = NULL;
@@ -3080,7 +3119,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
 
 	if (loadmodel->brush.numsubmodels)
-		loadmodel->brush.submodels = Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
+		loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
 
 	if (loadmodel->isworldmodel)
 	{
@@ -3147,7 +3186,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		mod->nummodelsurfaces = bm->numfaces;
 
 		// make the model surface list (used by shadowing/lighting)
-		mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+		mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
 		for (j = 0;j < mod->nummodelsurfaces;j++)
 			mod->surfacelist[j] = mod->firstmodelsurface + j;
 
@@ -3165,6 +3204,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->brush.BoxTouchingPVS = NULL;
 			mod->brush.BoxTouchingLeafPVS = NULL;
 			mod->brush.BoxTouchingVisibleLeafs = NULL;
+			mod->brush.FindBoxClusters = NULL;
 			mod->brush.LightPoint = NULL;
 			mod->brush.AmbientSoundLevelsForPoint = NULL;
 		}
@@ -3667,7 +3707,7 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 	loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
 	if (!l->filelen)
 		return;
-	loadmodel->brush.entities = Mem_Alloc(loadmodel->mempool, l->filelen);
+	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
 	memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
 	data = loadmodel->brush.entities;
 	// some Q3 maps override the lightgrid_cellsize with a worldspawn key
@@ -3712,11 +3752,11 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 	char firstpasstexturename[Q3PATHLENGTH];
 	char parameter[4][Q3PATHLENGTH];
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dtexture_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadTextures: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (texture_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->data_textures = out;
 	loadmodel->num_textures = count;
@@ -3734,7 +3774,7 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 	{
 		for (i = 0;i < search->numfilenames;i++)
 		{
-			if ((f = FS_LoadFile(search->filenames[i], tempmempool, false)))
+			if ((f = (char *)FS_LoadFile(search->filenames[i], tempmempool, false)))
 			{
 				text = f;
 				while (COM_ParseToken(&text, false))
@@ -3984,8 +4024,8 @@ parseerror:
 			//if (R_TextureHasAlpha(out->skin.base))
 			//	out->surfaceparms |= Q3SURFACEPARM_TRANS;
 		}
-		if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
-			if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
+		if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true))
+			if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true))
 				if (cls.state != ca_dedicated)
 					Con_Printf("%s: texture loading for shader \"%s\" failed (first layer \"%s\" not found either)\n", loadmodel->name, out->name, out->firstpasstexturename);
 		// no animation
@@ -4001,11 +4041,11 @@ static void Mod_Q3BSP_LoadPlanes(lump_t *l)
 	mplane_t *out;
 	int i, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dplane_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (mplane_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_planes = out;
 	loadmodel->brush.num_planes = count;
@@ -4026,11 +4066,11 @@ static void Mod_Q3BSP_LoadBrushSides(lump_t *l)
 	q3mbrushside_t *out;
 	int i, n, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dbrushside_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_brushsides = out;
 	loadmodel->brush.num_brushsides = count;
@@ -4055,11 +4095,11 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l)
 	int i, j, n, c, count, maxplanes;
 	mplane_t *planes;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dbrush_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (q3mbrush_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_brushes = out;
 	loadmodel->brush.num_brushes = count;
@@ -4086,7 +4126,7 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l)
 			maxplanes = out->numbrushsides;
 			if (planes)
 				Mem_Free(planes);
-			planes = Mem_Alloc(tempmempool, sizeof(mplane_t) * maxplanes);
+			planes = (mplane_t *)Mem_Alloc(tempmempool, sizeof(mplane_t) * maxplanes);
 		}
 		for (j = 0;j < out->numbrushsides;j++)
 		{
@@ -4106,11 +4146,11 @@ static void Mod_Q3BSP_LoadEffects(lump_t *l)
 	q3deffect_t *out;
 	int i, n, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3deffect_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadEffects: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (q3deffect_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq3.data_effects = out;
 	loadmodel->brushq3.num_effects = count;
@@ -4119,8 +4159,11 @@ static void Mod_Q3BSP_LoadEffects(lump_t *l)
 	{
 		strlcpy (out->shadername, in->shadername, sizeof (out->shadername));
 		n = LittleLong(in->brushindex);
-		if (n < 0 || n >= loadmodel->brush.num_brushes)
-			Host_Error("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
+		if (n >= loadmodel->brush.num_brushes)
+		{
+			Con_Printf("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes), setting to -1\n", n, loadmodel->brush.num_brushes);
+			n = -1;
+		}
 		out->brushindex = n;
 		out->unknown = LittleLong(in->unknown);
 	}
@@ -4131,11 +4174,11 @@ static void Mod_Q3BSP_LoadVertices(lump_t *l)
 	q3dvertex_t *in;
 	int i, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dvertex_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadVertices: funny lump size in %s",loadmodel->name);
 	loadmodel->brushq3.num_vertices = count = l->filelen / sizeof(*in);
-	loadmodel->brushq3.data_vertex3f = Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 4)));
+	loadmodel->brushq3.data_vertex3f = (float *)Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 4)));
 	loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_vertex3f + count * 3;
 	loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + count * 2;
 	loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
@@ -4163,11 +4206,11 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 	int *out;
 	int i, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (int *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(int[3]))
 		Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq3.num_triangles = count / 3;
 	loadmodel->brushq3.data_element3i = out;
@@ -4191,11 +4234,11 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l)
 
 	if (!l->filelen)
 		return;
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dlightmap_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (rtexture_t **)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq3.data_lightmaps = out;
 	loadmodel->brushq3.num_lightmaps = count;
@@ -4221,11 +4264,11 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	float *v;
 	surfmesh_t *mesh, *tempmeshlist[1024];
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dface_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadFaces: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (msurface_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->data_surfaces = out;
 	loadmodel->num_surfaces = count;
@@ -4355,7 +4398,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		i = oldi;
 		in = oldin;
 		out = oldout;
-		mesh = tempmeshlist[meshnum] = Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, false, true, false);
+		mesh = tempmeshlist[meshnum] = Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false);
 		meshvertices = 0;
 		meshtriangles = 0;
 		for (;i < count && meshvertices + out->num_vertices <= mesh->num_vertices;i++, in++, out++)
@@ -4458,8 +4501,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 				finalvertices = finalwidth * finalheight;
 				finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
 
-				out->data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
-				out->data_collisionelement3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
+				out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
+				out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
 				out->num_collisionvertices = finalvertices;
 				out->num_collisiontriangles = finaltriangles;
 				Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
@@ -4530,7 +4573,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	loadmodel->nummeshes = meshnum;
 	if (loadmodel->nummeshes)
 	{
-		loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *) * loadmodel->nummeshes);
+		loadmodel->meshlist = (surfmesh_t **)Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *) * loadmodel->nummeshes);
 		memcpy(loadmodel->meshlist, tempmeshlist, sizeof(surfmesh_t *) * loadmodel->nummeshes);
 	}
 
@@ -4553,11 +4596,11 @@ static void Mod_Q3BSP_LoadModels(lump_t *l)
 	q3dmodel_t *out;
 	int i, j, n, c, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dmodel_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadModels: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (q3dmodel_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brushq3.data_models = out;
 	loadmodel->brushq3.num_models = count;
@@ -4590,11 +4633,11 @@ static void Mod_Q3BSP_LoadLeafBrushes(lump_t *l)
 	int *out;
 	int i, n, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (int *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_leafbrushes = out;
 	loadmodel->brush.num_leafbrushes = count;
@@ -4614,11 +4657,11 @@ static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
 	int *out;
 	int i, n, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (int *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_leafsurfaces = out;
 	loadmodel->brush.num_leafsurfaces = count;
@@ -4638,11 +4681,11 @@ static void Mod_Q3BSP_LoadLeafs(lump_t *l)
 	mleaf_t *out;
 	int i, j, n, c, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dleaf_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_leafs = out;
 	loadmodel->brush.num_leafs = count;
@@ -4680,11 +4723,11 @@ static void Mod_Q3BSP_LoadNodes(lump_t *l)
 	mnode_t *out;
 	int i, j, n, count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dnode_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadNodes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+	out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
 	loadmodel->brush.data_nodes = out;
 	loadmodel->brush.num_nodes = count;
@@ -4731,7 +4774,7 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
 	q3dlightgrid_t *out;
 	int count;
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dlightgrid_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadLightGrid: funny lump size in %s",loadmodel->name);
 	loadmodel->brushq3.num_lightgrid_scale[0] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[0];
@@ -4757,7 +4800,7 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
 			Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)\n", l->filelen, count * sizeof(*in), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]);
 		if (l->filelen != count * (int)sizeof(*in))
 			Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", count * sizeof(*in), l->filelen);
-		out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+		out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 		loadmodel->brushq3.data_lightgrid = out;
 		loadmodel->brushq3.num_lightgrid = count;
 		// no swapping or validation necessary
@@ -4782,12 +4825,12 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l)
 		// create clusters
 		loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
 		totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
-		loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
+		loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
 		memset(loadmodel->brush.data_pvsclusters, 0xFF, totalchains);
 		return;
 	}
 
-	in = (void *)(mod_base + l->fileofs);
+	in = (q3dpvs_t *)(mod_base + l->fileofs);
 	if (l->filelen < 9)
 		Host_Error("Mod_Q3BSP_LoadPVS: funny lump size in %s",loadmodel->name);
 
@@ -4799,7 +4842,7 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l)
 	if (l->filelen < totalchains + (int)sizeof(*in))
 		Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)\n", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, totalchains + sizeof(*in), l->filelen);
 
-	loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
+	loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
 	memcpy(loadmodel->brush.data_pvsclusters, (qbyte *)(in + 1), totalchains);
 }
 
@@ -5512,6 +5555,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
 	mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
 	mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
+	mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
 	mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
 	mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
@@ -5603,6 +5647,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->brush.BoxTouchingPVS = NULL;
 			mod->brush.BoxTouchingLeafPVS = NULL;
 			mod->brush.BoxTouchingVisibleLeafs = NULL;
+			mod->brush.FindBoxClusters = NULL;
 			mod->brush.LightPoint = NULL;
 			mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
 		}
@@ -5613,7 +5658,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
 		mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
 		mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
-		mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+		mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
 		for (j = 0;j < mod->nummodelsurfaces;j++)
 			mod->surfacelist[j] = mod->firstmodelsurface + j;