X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=3e57add488ce07806c034e54cae62bd90670fe61;hp=b5c5cb94330b05547406e942fcba72b56f3712f2;hb=aa33d8f8642530f7f266d6cde1422f95aa74b2be;hpb=5d00fdd2bc32e9635c51a22bace2e0a883f3561f

diff --git a/model_brush.c b/model_brush.c
index b5c5cb94..3e57add4 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128"};
 cvar_t halflifebsp = {0, "halflifebsp", "0"};
+cvar_t mcbsp = {0, "mcbsp", "0"};
 cvar_t r_novis = {0, "r_novis", "0"};
 cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0"};
 cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1"};
@@ -48,6 +49,7 @@ void Mod_BrushInit(void)
 {
 //	Cvar_RegisterVariable(&r_subdivide_size);
 	Cvar_RegisterVariable(&halflifebsp);
+	Cvar_RegisterVariable(&mcbsp);
 	Cvar_RegisterVariable(&r_novis);
 	Cvar_RegisterVariable(&r_miplightmaps);
 	Cvar_RegisterVariable(&r_lightmaprgba);
@@ -637,6 +639,13 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 	VectorSubtract(boxstartmaxs, boxstartmins, boxsize);
 	if (boxsize[0] < 3)
 		rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
+	else if (model->brush.ismcbsp)
+	{
+		if (boxsize[2] < 48) // pick the nearest of 40 or 56
+			rhc.hull = &model->brushq1.hulls[2]; // 16x16x40
+		else
+			rhc.hull = &model->brushq1.hulls[1]; // 16x16x56
+	}
 	else if (model->brush.ishlbsp)
 	{
 		// LordHavoc: this has to have a minor tolerance (the .1) because of
@@ -1040,7 +1049,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++)
@@ -1132,7 +1141,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)
@@ -1151,7 +1160,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;
@@ -1167,7 +1176,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)
@@ -1324,10 +1333,15 @@ 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 = (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)
 	{
 		// LordHavoc: hope is not lost yet, check for a .lit file to load
@@ -1337,13 +1351,13 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 		data = (qbyte*) FS_LoadFile(litfilename, tempmempool, false);
 		if (data)
 		{
-			if (fs_filesize == (size_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
+			if (fs_filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
 			{
 				i = LittleLong(((int *)data)[1]);
 				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;
@@ -1366,7 +1380,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);
@@ -1406,7 +1420,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)
@@ -1449,7 +1463,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);
 }
 
@@ -1518,7 +1532,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);
@@ -1531,11 +1545,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;
@@ -1548,35 +1562,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);
 	}
 }
 
@@ -1586,11 +1628,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;
@@ -1608,11 +1650,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;
@@ -1809,18 +1851,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;
@@ -1830,12 +1872,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;
 
@@ -1880,8 +1922,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;
@@ -1895,7 +1935,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		}
 
 		// compile additional data about the surface geometry
-		Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, surface->groupmesh->data_vertex3f, surface->groupmesh->data_texcoordtexture2f, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle), surface->groupmesh->data_svector3f, surface->groupmesh->data_tvector3f, surface->groupmesh->data_normal3f);
+		Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, surface->groupmesh->data_vertex3f, surface->groupmesh->data_texcoordtexture2f, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle), surface->groupmesh->data_svector3f, surface->groupmesh->data_tvector3f, surface->groupmesh->data_normal3f, true);
 		BoxFromPoints(surface->mins, surface->maxs, surface->num_vertices, (surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex));
 
 		// generate surface extents information
@@ -1935,7 +1975,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);
 			}
@@ -1953,7 +1993,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);
 
@@ -2004,11 +2044,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;
@@ -2046,18 +2086,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++)
@@ -2102,88 +2142,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.ishlbsp)
+	for (i = 1; i < hullinfo->numhulls; i++)
 	{
-		hull = &loadmodel->brushq1.hulls[1];
+		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] = -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
-	{
-		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->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);
 	}
 
@@ -2208,7 +2194,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;
@@ -2228,11 +2214,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++)
 	{
@@ -2248,11 +2234,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]);
@@ -2265,12 +2251,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++)
 	{
@@ -2402,7 +2388,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;
@@ -2487,9 +2473,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++)
@@ -2600,7 +2586,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");
 
@@ -2792,10 +2778,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])
@@ -2885,7 +2871,16 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co
 	const hull_t *hull;
 
 	VectorSubtract(inmaxs, inmins, size);
-	if (cmodel->brush.ishlbsp)
+	if (cmodel->brush.ismcbsp)
+	{
+		if (size[0] < 3)
+			hull = &cmodel->brushq1.hulls[0]; // 0x0x0
+		else if (size[2] < 48) // pick the nearest of 40 or 56
+			hull = &cmodel->brushq1.hulls[2]; // 16x16x40
+		else
+			hull = &cmodel->brushq1.hulls[1]; // 16x16x56
+	}
+	else if (cmodel->brush.ishlbsp)
 	{
 		if (size[0] < 3)
 			hull = &cmodel->brushq1.hulls[0]; // 0x0x0
@@ -2912,12 +2907,7 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co
 	VectorAdd(inmins, hull->clip_size, outmaxs);
 }
 
-extern void R_Q1BSP_DrawSky(entity_render_t *ent);
-extern void R_Q1BSP_Draw(entity_render_t *ent);
-extern void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outleaflist, qbyte *outleafpvs, int *outnumleafspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
-extern void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist, const vec3_t lightmins, const vec3_t lightmaxs);
-extern void R_Q1BSP_DrawLight(entity_render_t *ent, float *lightcolor, int numsurfaces, const int *surfacelist);
-void Mod_Q1BSP_Load(model_t *mod, void *buffer)
+void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	int i, j, k;
 	dheader_t *header;
@@ -2926,15 +2916,93 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	float dist, modelyawradius, modelradius, *vec;
 	msurface_t *surface;
 	int numshadowmeshtriangles;
+	dheader_t _header;
+	hullinfo_t hullinfo;
 
 	mod->type = mod_brushq1;
 
-	header = (dheader_t *)buffer;
+	if (!memcmp (buffer, "MCBSPpad", 8))
+	{
+		qbyte	*index;
 
-	i = LittleLong(header->version);
-	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 = 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
+	{
+		header = (dheader_t *)buffer;
+
+		i = LittleLong(header->version);
+		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;
 	mod->TraceBox = Mod_Q1BSP_TraceBox;
@@ -2952,16 +3020,9 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
 
 	if (loadmodel->isworldmodel)
-		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
-
-// 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);
+		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
+		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
 	}
 
 // load into heap
@@ -2981,10 +3042,10 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	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;
@@ -3018,7 +3079,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	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)
 	{
@@ -3085,7 +3146,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 		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;
 
@@ -3093,6 +3154,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 		mod->DrawSky = NULL;
 		mod->Draw = R_Q1BSP_Draw;
 		mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+		mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
 		mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
 		mod->DrawLight = R_Q1BSP_DrawLight;
 		if (i != 0)
@@ -3158,7 +3220,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
 	//Mod_Q1BSP_ProcessLightList();
 
 	if (developer.integer)
-		Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brushq1.submodels[i].visleafs, loadmodel->brush.num_portals);
+		Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals);
 }
 
 static void Mod_Q2BSP_LoadEntities(lump_t *l)
@@ -3539,7 +3601,7 @@ static void Mod_Q2BSP_LoadModels(lump_t *l)
 */
 }
 
-void static Mod_Q2BSP_Load(model_t *mod, void *buffer)
+void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	int i;
 	q2dheader_t *header;
@@ -3554,8 +3616,12 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer)
 	if (i != Q2BSPVERSION)
 		Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
 	mod->brush.ishlbsp = false;
+	mod->brush.ismcbsp = false;
 	if (loadmodel->isworldmodel)
+	{
 		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
+		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
+	}
 
 	mod_base = (qbyte *)header;
 
@@ -3600,7 +3666,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
@@ -3645,11 +3711,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;
@@ -3667,7 +3733,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))
@@ -3710,9 +3776,9 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 											Con_Printf(" %s", parameter[j]);
 										Con_Print("\n");
 									}
-									if (passnumber == 0 && numparameters >= 1 && (flags & Q3SURFACEPARM_TRANS))
+									if (passnumber == 0 && numparameters >= 1)
 									{
-										if (!strcasecmp(parameter[0], "blendfunc"))
+										if (!strcasecmp(parameter[0], "blendfunc") && (flags & Q3SURFACEPARM_TRANS))
 										{
 											if (numparameters == 2 && !strcasecmp(parameter[1], "add"))
 												flags2 |= Q3TEXTUREFLAG_ADDITIVE;
@@ -3917,8 +3983,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
@@ -3934,11 +4000,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;
@@ -3959,11 +4025,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;
@@ -3988,11 +4054,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;
@@ -4019,7 +4085,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++)
 		{
@@ -4039,11 +4105,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;
@@ -4052,8 +4118,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);
 	}
@@ -4064,11 +4133,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;
@@ -4096,11 +4165,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;
@@ -4124,11 +4193,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;
@@ -4154,11 +4223,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;
@@ -4288,7 +4357,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++)
@@ -4391,8 +4460,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);
@@ -4427,7 +4496,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 				Con_Print("\n");
 			}
 			// for per pixel lighting
-			Mod_BuildTextureVectorsAndNormals(out->num_firstvertex, out->num_vertices, out->num_triangles, out->groupmesh->data_vertex3f, out->groupmesh->data_texcoordtexture2f, (out->groupmesh->data_element3i + 3 * out->num_firsttriangle), out->groupmesh->data_svector3f, out->groupmesh->data_tvector3f, out->groupmesh->data_normal3f);
+			Mod_BuildTextureVectorsAndNormals(out->num_firstvertex, out->num_vertices, out->num_triangles, out->groupmesh->data_vertex3f, out->groupmesh->data_texcoordtexture2f, (out->groupmesh->data_element3i + 3 * out->num_firsttriangle), out->groupmesh->data_svector3f, out->groupmesh->data_tvector3f, out->groupmesh->data_normal3f, true);
 			// calculate a bounding box
 			VectorClear(out->mins);
 			VectorClear(out->maxs);
@@ -4463,7 +4532,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);
 	}
 
@@ -4486,11 +4555,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;
@@ -4523,11 +4592,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;
@@ -4547,11 +4616,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;
@@ -4571,11 +4640,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;
@@ -4613,11 +4682,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;
@@ -4664,7 +4733,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];
@@ -4680,40 +4749,22 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
 	loadmodel->brushq3.num_lightgrid_isize[1] = loadmodel->brushq3.num_lightgrid_imaxs[1] - loadmodel->brushq3.num_lightgrid_imins[1] + 1;
 	loadmodel->brushq3.num_lightgrid_isize[2] = loadmodel->brushq3.num_lightgrid_imaxs[2] - loadmodel->brushq3.num_lightgrid_imins[2] + 1;
 	count = loadmodel->brushq3.num_lightgrid_isize[0] * loadmodel->brushq3.num_lightgrid_isize[1] * loadmodel->brushq3.num_lightgrid_isize[2];
+	Matrix4x4_CreateScale3(&loadmodel->brushq3.num_lightgrid_indexfromworld, loadmodel->brushq3.num_lightgrid_scale[0], loadmodel->brushq3.num_lightgrid_scale[1], loadmodel->brushq3.num_lightgrid_scale[2]);
+	Matrix4x4_ConcatTranslate(&loadmodel->brushq3.num_lightgrid_indexfromworld, -loadmodel->brushq3.num_lightgrid_imins[0] * loadmodel->brushq3.num_lightgrid_cellsize[0], -loadmodel->brushq3.num_lightgrid_imins[1] * loadmodel->brushq3.num_lightgrid_cellsize[1], -loadmodel->brushq3.num_lightgrid_imins[2] * loadmodel->brushq3.num_lightgrid_cellsize[2]);
+
+	// if lump is empty there is nothing to load, we can deal with that in the LightPoint code
 	if (l->filelen)
 	{
 		if (l->filelen < count * (int)sizeof(*in))
 			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));
-	loadmodel->brushq3.data_lightgrid = out;
-	loadmodel->brushq3.num_lightgrid = count;
-
-	// no swapping or validation necessary
-	if (l->filelen)
+		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
 		memcpy(out, in, count * (int)sizeof(*out));
-	else
-	{
-		// no data, fill with white
-		int i;
-		for (i = 0;i < count;i++)
-		{
-			out[i].ambientrgb[0] = 128;
-			out[i].ambientrgb[1] = 128;
-			out[i].ambientrgb[2] = 128;
-			out[i].diffusergb[0] = 0;
-			out[i].diffusergb[1] = 0;
-			out[i].diffusergb[2] = 0;
-			out[i].diffusepitch = 0;
-			out[i].diffuseyaw = 0;
-		}
 	}
-
-	Matrix4x4_CreateScale3(&loadmodel->brushq3.num_lightgrid_indexfromworld, loadmodel->brushq3.num_lightgrid_scale[0], loadmodel->brushq3.num_lightgrid_scale[1], loadmodel->brushq3.num_lightgrid_scale[2]);
-	Matrix4x4_ConcatTranslate(&loadmodel->brushq3.num_lightgrid_indexfromworld, -loadmodel->brushq3.num_lightgrid_imins[0] * loadmodel->brushq3.num_lightgrid_cellsize[0], -loadmodel->brushq3.num_lightgrid_imins[1] * loadmodel->brushq3.num_lightgrid_cellsize[1], -loadmodel->brushq3.num_lightgrid_imins[2] * loadmodel->brushq3.num_lightgrid_cellsize[2]);
 }
 
 static void Mod_Q3BSP_LoadPVS(lump_t *l)
@@ -4733,12 +4784,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);
 
@@ -4750,7 +4801,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);
 }
 
@@ -4759,7 +4810,6 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc
 	int i, j, k, index[3];
 	float transformed[3], blend1, blend2, blend, yaw, pitch, sinpitch;
 	q3dlightgrid_t *a, *s;
-	// FIXME: write this
 	if (!model->brushq3.num_lightgrid)
 	{
 		ambientcolor[0] = 1;
@@ -5431,7 +5481,7 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
 		loadmodel->brush.num_leafs = numleafs;
 }
 
-void Mod_Q3BSP_Load(model_t *mod, void *buffer)
+void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	int i, j, numshadowmeshtriangles;
 	q3dheader_t *header;
@@ -5447,8 +5497,13 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer)
 	i = LittleLong(header->version);
 	if (i != Q3BSPVERSION)
 		Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
-	if (mod->isworldmodel)
-		Cvar_SetValue("halflifebsp", false);
+	mod->brush.ishlbsp = false;
+	mod->brush.ismcbsp = false;
+	if (loadmodel->isworldmodel)
+	{
+		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
+		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
+	}
 
 	mod->soundfromcenter = true;
 	mod->TraceBox = Mod_Q3BSP_TraceBox;
@@ -5464,6 +5519,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer)
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
 	mod->Draw = R_Q1BSP_Draw;
 	mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+	mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
 	mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
 	mod->DrawLight = R_Q1BSP_DrawLight;
 
@@ -5559,7 +5615,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer)
 		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;
 
@@ -5587,18 +5643,18 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer)
 	}
 }
 
-void Mod_IBSP_Load(model_t *mod, void *buffer)
+void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	int i = LittleLong(((int *)buffer)[1]);
 	if (i == Q3BSPVERSION)
-		Mod_Q3BSP_Load(mod,buffer);
+		Mod_Q3BSP_Load(mod,buffer, bufferend);
 	else if (i == Q2BSPVERSION)
-		Mod_Q2BSP_Load(mod,buffer);
+		Mod_Q2BSP_Load(mod,buffer, bufferend);
 	else
 		Host_Error("Mod_IBSP_Load: unknown/unsupported version %i\n", i);
 }
 
-void Mod_MAP_Load(model_t *mod, void *buffer)
+void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	Host_Error("Mod_MAP_Load: not yet implemented\n");
 }