X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=47cf815d4dff80942a594ecc821c80bc13c743e6;hp=505e7656f52ad49c24c912112bc47fad8437aab4;hb=1a476882427593a562b624379f137bf8821db951;hpb=ed90aa6c4030e69afb8cb659540519af9fb30a9c

diff --git a/model_brush.c b/model_brush.c
index 505e7656..47cf815d 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -26,24 +26,24 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "wad.h"
 
 
-//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"};
-cvar_t r_nosurftextures = {0, "r_nosurftextures", "0"};
-cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4"};
-cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1"};
-cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024"};
-cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536"};
-cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15"};
-cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1"};
-cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024"};
-cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225"};
-cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1"};
-cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1"};
-cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0"};
+//cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"};
+cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
+cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"};
+cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
+cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0", "mipmaps lightmaps on upload, also expanding them to power of 2 sizes, this runs slower"};
+cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"};
+cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
+cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
+cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
+cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
+cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
+cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
+cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"};
+cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"};
 
 void Mod_BrushInit(void)
 {
@@ -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;
@@ -85,7 +83,7 @@ static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
 	return (mleaf_t *)node;
 }
 
-static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, qbyte *out, int outsize)
+static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize)
 {
 	int i;
 	mleaf_t *leaf;
@@ -104,23 +102,92 @@ static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p,
 		memset(out, 0, outsize);
 }
 
-static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
 {
-	int clusterindex, side, nodestackindex = 0;
+	int numclusters = 0;
+	int nodestackindex = 0;
+	mnode_t *node, *nodestack[1024];
+	if (!model->brush.num_pvsclusters)
+		return -1;
+	node = model->brush.data_nodes;
+	for (;;)
+	{
+#if 1
+		if (node->plane)
+		{
+			// node - recurse down the BSP tree
+			int sides = BoxOnPlaneSide(mins, maxs, node->plane);
+			if (sides < 3)
+			{
+				if (sides == 0)
+					return -1; // ERROR: NAN bounding box!
+				// box is on one side of plane, take that path
+				node = node->children[sides-1];
+			}
+			else
+			{
+				// box crosses plane, take one path and remember the other
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+			}
+			continue;
+		}
+		else
+		{
+			// leaf - add clusterindex to list
+			if (numclusters < maxclusters)
+				clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
+			numclusters++;
+		}
+#else
+		if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+		{
+			if (node->plane)
+			{
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+				continue;
+			}
+			else
+			{
+				// leaf - add clusterindex to list
+				if (numclusters < maxclusters)
+					clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
+				numclusters++;
+			}
+		}
+#endif
+		// 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 unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
+{
+	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
 	if (!model->brush.num_pvsclusters)
 		return true;
 	node = model->brush.data_nodes;
 	for (;;)
 	{
+#if 1
 		if (node->plane)
 		{
 			// node - recurse down the BSP tree
-			side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
-			if (side < 2)
+			int sides = BoxOnPlaneSide(mins, maxs, node->plane);
+			if (sides < 3)
 			{
+				if (sides == 0)
+					return -1; // ERROR: NAN bounding box!
 				// box is on one side of plane, take that path
-				node = node->children[side];
+				node = node->children[sides-1];
 			}
 			else
 			{
@@ -129,46 +196,69 @@ static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3
 					nodestack[nodestackindex++] = node->children[0];
 				node = node->children[1];
 			}
+			continue;
 		}
 		else
 		{
 			// leaf - check cluster bit
-			clusterindex = ((mleaf_t *)node)->clusterindex;
+			int clusterindex = ((mleaf_t *)node)->clusterindex;
 			if (CHECKPVSBIT(pvs, clusterindex))
 			{
 				// it is visible, return immediately with the news
 				return true;
 			}
+		}
+#else
+		if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+		{
+			if (node->plane)
+			{
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+				continue;
+			}
 			else
 			{
-				// nothing to see here, try another path we didn't take earlier
-				if (nodestackindex == 0)
-					break;
-				node = nodestack[--nodestackindex];
+				// leaf - check cluster bit
+				int clusterindex = ((mleaf_t *)node)->clusterindex;
+				if (CHECKPVSBIT(pvs, clusterindex))
+				{
+					// it is visible, return immediately with the news
+					return true;
+				}
 			}
 		}
+#endif
+		// nothing to see here, try another path we didn't take earlier
+		if (nodestackindex == 0)
+			break;
+		node = nodestack[--nodestackindex];
 	}
 	// it is not visible
 	return false;
 }
 
-static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
 {
-	int clusterindex, side, nodestackindex = 0;
+	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
 	if (!model->brush.num_leafs)
 		return true;
 	node = model->brush.data_nodes;
 	for (;;)
 	{
+#if 1
 		if (node->plane)
 		{
 			// node - recurse down the BSP tree
-			side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
-			if (side < 2)
+			int sides = BoxOnPlaneSide(mins, maxs, node->plane);
+			if (sides < 3)
 			{
+				if (sides == 0)
+					return -1; // ERROR: NAN bounding box!
 				// box is on one side of plane, take that path
-				node = node->children[side];
+				node = node->children[sides-1];
 			}
 			else
 			{
@@ -177,44 +267,69 @@ static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const qbyte *pvs, const
 					nodestack[nodestackindex++] = node->children[0];
 				node = node->children[1];
 			}
+			continue;
 		}
 		else
 		{
 			// leaf - check cluster bit
-			clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
+			int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
 			if (CHECKPVSBIT(pvs, clusterindex))
 			{
 				// it is visible, return immediately with the news
 				return true;
 			}
+		}
+#else
+		if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+		{
+			if (node->plane)
+			{
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+				continue;
+			}
 			else
 			{
-				// nothing to see here, try another path we didn't take earlier
-				if (nodestackindex == 0)
-					break;
-				node = nodestack[--nodestackindex];
+				// leaf - check cluster bit
+				int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
+				if (CHECKPVSBIT(pvs, clusterindex))
+				{
+					// it is visible, return immediately with the news
+					return true;
+				}
 			}
 		}
+#endif
+		// nothing to see here, try another path we didn't take earlier
+		if (nodestackindex == 0)
+			break;
+		node = nodestack[--nodestackindex];
 	}
 	// it is not visible
 	return false;
 }
 
-static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibleleafs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
 {
-	int side, nodestackindex = 0;
+	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
+	if (!model->brush.num_leafs)
+		return true;
 	node = model->brush.data_nodes;
 	for (;;)
 	{
+#if 1
 		if (node->plane)
 		{
 			// node - recurse down the BSP tree
-			side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
-			if (side < 2)
+			int sides = BoxOnPlaneSide(mins, maxs, node->plane);
+			if (sides < 3)
 			{
+				if (sides == 0)
+					return -1; // ERROR: NAN bounding box!
 				// box is on one side of plane, take that path
-				node = node->children[side];
+				node = node->children[sides-1];
 			}
 			else
 			{
@@ -223,6 +338,7 @@ static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibl
 					nodestack[nodestackindex++] = node->children[0];
 				node = node->children[1];
 			}
+			continue;
 		}
 		else
 		{
@@ -232,14 +348,32 @@ static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibl
 				// it is visible, return immediately with the news
 				return true;
 			}
+		}
+#else
+		if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+		{
+			if (node->plane)
+			{
+				if (nodestackindex < 1024)
+					nodestack[nodestackindex++] = node->children[0];
+				node = node->children[1];
+				continue;
+			}
 			else
 			{
-				// nothing to see here, try another path we didn't take earlier
-				if (nodestackindex == 0)
-					break;
-				node = nodestack[--nodestackindex];
+				// leaf - check if it is visible
+				if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
+				{
+					// it is visible, return immediately with the news
+					return true;
+				}
 			}
 		}
+#endif
+		// nothing to see here, try another path we didn't take earlier
+		if (nodestackindex == 0)
+			break;
+		node = nodestack[--nodestackindex];
 	}
 	// it is not visible
 	return false;
@@ -429,7 +563,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;
@@ -623,7 +757,7 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i
 }
 #endif
 
-static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t boxstartmins, const vec3_t boxstartmaxs, const vec3_t boxendmins, const vec3_t boxendmaxs, int hitsupercontentsmask)
+static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
 {
 	// this function currently only supports same size start and end
 	double boxsize[3];
@@ -636,7 +770,7 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 	rhc.trace->fraction = 1;
 	rhc.trace->realfraction = 1;
 	rhc.trace->allsolid = true;
-	VectorSubtract(boxstartmaxs, boxstartmins, boxsize);
+	VectorSubtract(boxmaxs, boxmins, boxsize);
 	if (boxsize[0] < 3)
 		rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
 	else if (model->brush.ismcbsp)
@@ -669,15 +803,15 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 		else
 			rhc.hull = &model->brushq1.hulls[2]; // 64x64x88
 	}
-	VectorSubtract(boxstartmins, rhc.hull->clip_mins, rhc.start);
-	VectorSubtract(boxendmins, rhc.hull->clip_mins, rhc.end);
+	VectorMAMAM(1, start, 1, boxmins, -1, rhc.hull->clip_mins, rhc.start);
+	VectorMAMAM(1, end, 1, boxmins, -1, rhc.hull->clip_mins, rhc.end);
 	VectorSubtract(rhc.end, rhc.start, rhc.dist);
 #if COLLISIONPARANOID >= 2
 	Con_Printf("t(%f %f %f,%f %f %f,%i %f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2], rhc.hull - model->brushq1.hulls, rhc.hull->clip_mins[0], rhc.hull->clip_mins[1], rhc.hull->clip_mins[2]);
 	Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
 	Con_Print("\n");
 #else
-	if (DotProduct(rhc.dist, rhc.dist))
+	if (VectorLength2(rhc.dist))
 		Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
 	else
 		Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
@@ -847,7 +981,7 @@ loc0:
 
 				if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1])
 				{
-					qbyte *lightmap;
+					unsigned char *lightmap;
 					int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
 					lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1);
 					lmheight = ((surface->lightmapinfo->extents[1]>>4)+1);
@@ -858,7 +992,7 @@ loc0:
 
 					for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++)
 					{
-						scale = d_lightstylevalue[surface->lightmapinfo->styles[maps]];
+						scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]];
 						r00 += lightmap[      0] * scale;g00 += lightmap[      1] * scale;b00 += lightmap[      2] * scale;
 						r01 += lightmap[      3] * scale;g01 += lightmap[      4] * scale;b01 += lightmap[      5] * scale;
 						r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
@@ -918,12 +1052,13 @@ middle sample (the one which was requested)
 void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
 {
 	Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
+	VectorSet(diffusenormal, 0, 0, -1);
 }
 
-static void Mod_Q1BSP_DecompressVis(const qbyte *in, const qbyte *inend, qbyte *out, qbyte *outend)
+static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend)
 {
 	int c;
-	qbyte *outstart = out;
+	unsigned char *outstart = out;
 	while (out < outend)
 	{
 		if (in == inend)
@@ -961,7 +1096,7 @@ R_Q1BSP_LoadSplitSky
 A sky texture is 256*128, with the right side being a masked overlay
 ==============
 */
-void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
+void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel)
 {
 	int i, j;
 	unsigned solidpixels[128*128], alphapixels[128*128];
@@ -970,7 +1105,7 @@ void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
 	if (width != 256 || height != 128)
 	{
 		loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
-		loadmodel->brush.alphaskytexture = NULL;;
+		loadmodel->brush.alphaskytexture = NULL;
 		return;
 	}
 
@@ -1021,8 +1156,8 @@ void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
 		}
 	}
 
-	loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (qbyte *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
-	loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (qbyte *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+	loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+	loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
 }
 
 static void Mod_Q1BSP_LoadTextures(lump_t *l)
@@ -1031,8 +1166,8 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 	miptex_t *dmiptex;
 	texture_t *tx, *tx2, *anims[10], *altanims[10];
 	dmiptexlump_t *m;
-	qbyte *data, *mtdata;
-	char name[256];
+	unsigned char *data, *mtdata;
+	char name[MAX_QPATH];
 
 	loadmodel->data_textures = NULL;
 
@@ -1049,7 +1184,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++)
@@ -1083,7 +1218,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		dofs[i] = LittleLong(dofs[i]);
 		if (dofs[i] == -1 || r_nosurftextures.integer)
 			continue;
-		dmiptex = (miptex_t *)((qbyte *)m + dofs[i]);
+		dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]);
 
 		// make sure name is no more than 15 characters
 		for (j = 0;dmiptex->name[j] && j < 15;j++)
@@ -1102,7 +1237,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 				Con_Printf("Texture \"%s\" in \"%s\"is corrupt or incomplete\n", dmiptex->name, loadmodel->name);
 				continue;
 			}
-			mtdata = (qbyte *)dmiptex + j;
+			mtdata = (unsigned char *)dmiptex + j;
 		}
 
 		if ((mtwidth & 15) || (mtheight & 15))
@@ -1124,67 +1259,57 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			Con_Printf("warning: unnamed texture in %s, renaming to %s\n", loadmodel->name, tx->name);
 		}
 
-		// LordHavoc: HL sky textures are entirely different than quake
-		if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
+		if (cls.state != ca_dedicated)
 		{
-			if (loadmodel->isworldmodel)
+			// LordHavoc: HL sky textures are entirely different than quake
+			if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
 			{
-				data = loadimagepixels(tx->name, false, 0, 0);
-				if (data)
+				if (loadmodel->isworldmodel)
 				{
-					R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
-					Mem_Free(data);
+					data = loadimagepixels(tx->name, false, 0, 0);
+					if (data)
+					{
+						R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
+						Mem_Free(data);
+					}
+					else if (mtdata != NULL)
+						R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
 				}
-				else if (mtdata != NULL)
-					R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
 			}
-		}
-		else
-		{
-			if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true))
+			else
 			{
-				// did not find external texture, load it from the bsp or wad3
-				if (loadmodel->brush.ishlbsp)
+				if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true))
 				{
-					// internal texture overrides wad
-					qbyte *pixels, *freepixels, *fogpixels;
-					pixels = freepixels = NULL;
-					if (mtdata)
-						pixels = W_ConvertWAD3Texture(dmiptex);
-					if (pixels == NULL)
-						pixels = freepixels = W_GetTexture(tx->name);
-					if (pixels != NULL)
+					// did not find external texture, load it from the bsp or wad3
+					if (loadmodel->brush.ishlbsp)
 					{
-						tx->width = image_width;
-						tx->height = image_height;
-						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))
+						// internal texture overrides wad
+						unsigned char *pixels, *freepixels;
+						pixels = freepixels = NULL;
+						if (mtdata)
+							pixels = W_ConvertWAD3Texture(dmiptex);
+						if (pixels == NULL)
+							pixels = freepixels = W_GetTexture(tx->name);
+						if (pixels != NULL)
 						{
-							fogpixels = Mem_Alloc(tempmempool, image_width * image_height * 4);
-							for (j = 0;j < image_width * image_height * 4;j += 4)
-							{
-								fogpixels[j + 0] = 255;
-								fogpixels[j + 1] = 255;
-								fogpixels[j + 2] = 255;
-								fogpixels[j + 3] = pixels[j + 3];
-							}
-							tx->skin.fog = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
-							Mem_Free(fogpixels);
+							tx->width = image_width;
+							tx->height = image_height;
+							Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, false, pixels, image_width, image_height, 32, NULL, NULL);
 						}
+						if (freepixels)
+							Mem_Free(freepixels);
 					}
-					if (freepixels)
-						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] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL);
 				}
-				else if (mtdata) // texture included
-					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)
-		{
-			// no texture found
-			tx->width = 16;
-			tx->height = 16;
-			tx->skin.base = r_texture_notexture;
+			if (tx->skin.base == NULL)
+			{
+				// no texture found
+				tx->width = 16;
+				tx->height = 16;
+				tx->skin.base = r_texture_notexture;
+			}
 		}
 
 		tx->basematerialflags = 0;
@@ -1192,12 +1317,10 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		{
 			// turb does not block movement
 			tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES;
-			// LordHavoc: some turbulent textures should be fullbright and solid
-			if (!strncmp(tx->name,"*lava",5)
-			 || !strncmp(tx->name,"*teleport",9)
-			 || !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
-				tx->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
-			else
+			// LordHavoc: some turbulent textures should not be affected by wateralpha
+			if (strncmp(tx->name,"*lava",5)
+			 && strncmp(tx->name,"*teleport",9)
+			 && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
 				tx->basematerialflags |= MATERIALFLAG_WATERALPHA;
 			if (!strncmp(tx->name, "*lava", 5))
 				tx->supercontents = SUPERCONTENTS_LAVA;
@@ -1328,18 +1451,19 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 static void Mod_Q1BSP_LoadLighting(lump_t *l)
 {
 	int i;
-	qbyte *in, *out, *data, d;
+	unsigned char *in, *out, *data, d;
 	char litfilename[1024];
+	fs_offset_t filesize;
 	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 = (unsigned char *)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 = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
 		memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
 	}
 	else // LordHavoc: bsp version 29 (normal white lighting)
@@ -1348,17 +1472,17 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 		strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
 		FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
 		strlcat (litfilename, ".lit", sizeof (litfilename));
-		data = (qbyte*) FS_LoadFile(litfilename, tempmempool, false);
+		data = (unsigned char*) FS_LoadFile(litfilename, tempmempool, false, &filesize);
 		if (data)
 		{
-			if (fs_filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
+			if (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);
-					memcpy(loadmodel->brushq1.lightdata, data + 8, fs_filesize - 8);
+					loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
+					memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8);
 					Mem_Free(data);
 					return;
 				}
@@ -1370,17 +1494,17 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 			}
 			else
 			{
-				if (fs_filesize == 8)
+				if (filesize == 8)
 					Con_Print("Empty .lit file, ignoring\n");
 				else
-					Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", fs_filesize, 8 + l->filelen * 3);
+					Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", filesize, 8 + l->filelen * 3);
 				Mem_Free(data);
 			}
 		}
 		// 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 = (unsigned char *)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);
@@ -1394,68 +1518,6 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 	}
 }
 
-static void Mod_Q1BSP_LoadLightList(void)
-{
-	int a, n, numlights;
-	char tempchar, *s, *t, *lightsstring, lightsfilename[1024];
-	mlight_t *e;
-
-	strlcpy (lightsfilename, loadmodel->name, sizeof (lightsfilename));
-	FS_StripExtension (lightsfilename, lightsfilename, sizeof(lightsfilename));
-	strlcat (lightsfilename, ".lights", sizeof (lightsfilename));
-	s = lightsstring = (char *) FS_LoadFile(lightsfilename, tempmempool, false);
-	if (s)
-	{
-		numlights = 0;
-		while (*s)
-		{
-			while (*s && *s != '\n' && *s != '\r')
-				s++;
-			if (!*s)
-			{
-				Mem_Free(lightsstring);
-				Con_Printf("lights file must end with a newline\n");
-				return;
-			}
-			s++;
-			numlights++;
-		}
-		loadmodel->brushq1.lights = Mem_Alloc(loadmodel->mempool, numlights * sizeof(mlight_t));
-		s = lightsstring;
-		n = 0;
-		while (*s && n < numlights)
-		{
-			t = s;
-			while (*s && *s != '\n' && *s != '\r')
-				s++;
-			if (!*s)
-			{
-				Con_Printf("misparsed lights file!\n");
-				break;
-			}
-			e = loadmodel->brushq1.lights + n;
-			tempchar = *s;
-			*s = 0;
-			a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &e->origin[0], &e->origin[1], &e->origin[2], &e->falloff, &e->light[0], &e->light[1], &e->light[2], &e->subtract, &e->spotdir[0], &e->spotdir[1], &e->spotdir[2], &e->spotcone, &e->distbias, &e->style);
-			*s = tempchar;
-			if (a != 14)
-			{
-				Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
-				break;
-			}
-			if (*s == '\r')
-				s++;
-			if (*s == '\n')
-				s++;
-			n++;
-		}
-		if (*s)
-			Con_Printf("misparsed lights file!\n");
-		loadmodel->brushq1.numlights = numlights;
-		Mem_Free(lightsstring);
-	}
-}
-
 static void Mod_Q1BSP_LoadVisibility(lump_t *l)
 {
 	loadmodel->brushq1.num_compressedpvs = 0;
@@ -1463,7 +1525,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 = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
 	memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen);
 }
 
@@ -1493,18 +1555,18 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 			key[strlen(key)-1] = 0;
 		if (!COM_ParseToken(&data, false))
 			return; // error
-		strcpy(value, com_token);
+		dpsnprintf(value, sizeof(value), "%s", com_token);
 		if (!strcmp("wad", key)) // for HalfLife maps
 		{
 			if (loadmodel->brush.ishlbsp)
 			{
 				j = 0;
-				for (i = 0;i < 4096;i++)
+				for (i = 0;i < (int)sizeof(value);i++)
 					if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
 						break;
 				if (value[i])
 				{
-					for (;i < 4096;i++)
+					for (;i < (int)sizeof(value);i++)
 					{
 						// ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
 						if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
@@ -1532,7 +1594,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 +1607,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,18 +1624,42 @@ static void Mod_Q1BSP_LoadVertexes(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 (unsigned char **buffer)
+{
+	int	i;
+	i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]);
+	(*buffer) += 4;
+	return i;
+}
+
+// REMOVEME
+float SB_ReadFloat (unsigned char **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)
 {
-	qbyte		*index;
+	unsigned char		*index;
 	dmodel_t	*out;
 	int			i, j, count;
 
-	index = (qbyte *)(mod_base + l->fileofs);
+	index = (unsigned char *)(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 = Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
+	out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brushq1.submodels = out;
 	loadmodel->brush.numsubmodels = count;
@@ -1581,23 +1667,20 @@ static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo)
 	for (i = 0; i < count; i++, out++)
 	{
 	// spread out the mins / maxs by a pixel
-		out->mins[0] = LittleFloat(*(float*)index) - 1; index += 4;
-		out->mins[1] = LittleFloat(*(float*)index) - 1; index += 4;
-		out->mins[2] = LittleFloat(*(float*)index) - 1; index += 4;
-		out->maxs[0] = LittleFloat(*(float*)index) + 1; index += 4;
-		out->maxs[1] = LittleFloat(*(float*)index) + 1; index += 4;
-		out->maxs[2] = LittleFloat(*(float*)index) + 1; index += 4;
-		out->origin[0] = LittleFloat (*(float*)index); index += 4;
-		out->origin[1] = LittleFloat (*(float*)index); index += 4;
-		out->origin[2] = LittleFloat (*(float*)index); index += 4;
+		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] = LittleLong (*(int*)index);
-			index += 4;
-		}
-		out->visleafs = LittleLong (*(int*)index); index += 4;
-		out->firstface = LittleLong (*(int*)index); index += 4;
-		out->numfaces = LittleLong (*(int*)index); index += 4;
+			out->headnode[j] = SB_ReadInt (&index);
+		out->visleafs = SB_ReadInt (&index);
+		out->firstface = SB_ReadInt (&index);
+		out->numfaces = SB_ReadInt (&index);
 	}
 }
 
@@ -1607,11 +1690,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;
@@ -1620,6 +1703,12 @@ static void Mod_Q1BSP_LoadEdges(lump_t *l)
 	{
 		out->v[0] = (unsigned short)LittleShort(in->v[0]);
 		out->v[1] = (unsigned short)LittleShort(in->v[1]);
+		if (out->v[0] >= loadmodel->brushq1.numvertexes || out->v[1] >= loadmodel->brushq1.numvertexes)
+		{
+			Con_Printf("Mod_Q1BSP_LoadEdges: %s has invalid vertex indices in edge %i (vertices %i %i >= numvertices %i)\n", loadmodel->name, i, out->v[0], out->v[1], loadmodel->brushq1.numvertexes);
+			out->v[0] = 0;
+			out->v[1] = 0;
+		}
 	}
 }
 
@@ -1629,11 +1718,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;
@@ -1801,7 +1890,7 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface)
 	subdivpolyverts = 0;
 	SubdividePolygon(surface->num_vertices, (surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex));
 	if (subdivpolytriangles < 1)
-		Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?\n");
+		Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?");
 
 	surface->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
 	mesh->num_vertices = subdivpolyverts;
@@ -1830,18 +1919,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;
@@ -1851,12 +1940,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 = (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;
 
@@ -1864,16 +1953,16 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		firstedge = LittleLong(in->firstedge);
 		numedges = LittleShort(in->numedges);
 		if ((unsigned int) firstedge > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) firstedge + (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges)
-			Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)\n", firstedge, numedges, loadmodel->brushq1.numsurfedges);
+			Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges);
 		i = LittleShort(in->texinfo);
 		if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
-			Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)\n", i, loadmodel->brushq1.numtexinfo);
+			Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo);
 		surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i;
 		surface->texture = surface->lightmapinfo->texinfo->texture;
 
 		planenum = LittleShort(in->planenum);
 		if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
-			Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)\n", planenum, loadmodel->brush.num_planes);
+			Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes);
 
 		//surface->flags = surface->texture->flags;
 		//if (LittleShort(in->side))
@@ -1943,8 +2032,6 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		// lighting info
 		for (i = 0;i < MAXLIGHTMAPS;i++)
 			surface->lightmapinfo->styles[i] = in->styles[i];
-		// force lightmap upload on first time seeing the surface
-		surface->cached_dlight = true;
 		surface->lightmapinfo->lightmaptexturestride = 0;
 		surface->lightmaptexture = NULL;
 		i = LittleLong(in->lightofs);
@@ -1954,7 +2041,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 = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
 				surface->lightmapinfo->styles[0] = 0;
 				memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
 			}
@@ -1964,6 +2051,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		else // LordHavoc: white lighting (bsp version 29)
 			surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (i * 3);
 
+		// check if we should apply a lightmap to this
 		if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples)
 		{
 			int i, iu, iv;
@@ -1971,8 +2059,10 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
 			if (ssize > 256 || tsize > 256)
 				Host_Error("Bad surface extents");
+			// force lightmap upload on first time seeing the surface
+			surface->cached_dlight = true;
 			// stainmap for permanent marks on walls
-			surface->lightmapinfo->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+			surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
 			// clear to white
 			memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
 
@@ -2008,7 +2098,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
 {
 	//if (node->parent)
-	//	Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion\n");
+	//	Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion");
 	node->parent = parent;
 	if (node->plane)
 	{
@@ -2023,11 +2113,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;
@@ -2065,18 +2155,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++)
@@ -2127,11 +2217,11 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 	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;
@@ -2158,7 +2248,7 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 		out->children[0] = LittleShort(in->children[0]);
 		out->children[1] = LittleShort(in->children[1]);
 		if (out->children[0] >= count || out->children[1] >= count)
-			Host_Error("Corrupt clipping hull(out of range child)\n");
+			Host_Error("Corrupt clipping hull(out of range child)");
 	}
 }
 
@@ -2173,7 +2263,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;
@@ -2193,11 +2283,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++)
 	{
@@ -2213,11 +2303,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]);
@@ -2230,12 +2320,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++)
 	{
@@ -2258,7 +2348,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 	char mapfilename[MAX_QPATH];
 	FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
 	strlcat (mapfilename, ".map", sizeof (mapfilename));
-	maptext = (qbyte*) FS_LoadFile(mapfilename, tempmempool, false);
+	maptext = (unsigned char*) FS_LoadFile(mapfilename, tempmempool, false, NULL);
 	if (!maptext)
 		return;
 	text = maptext;
@@ -2367,7 +2457,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;
@@ -2405,7 +2495,8 @@ static void Mod_Q1BSP_FinalizePortals(void)
 	mvertex_t *point;
 	mleaf_t *leaf, *endleaf;
 
-	// recalculate bounding boxes for all leafs(because qbsp is very sloppy)
+	// tally up portal and point counts and recalculate bounding boxes for all
+	// leafs (because qbsp is very sloppy)
 	leaf = loadmodel->brush.data_leafs;
 	endleaf = leaf + loadmodel->brush.num_leafs;
 	for (;leaf < endleaf;leaf++)
@@ -2414,31 +2505,6 @@ static void Mod_Q1BSP_FinalizePortals(void)
 		VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
 	}
 	p = portalchain;
-	while (p)
-	{
-		if (p->numpoints >= 3)
-		{
-			for (i = 0;i < 2;i++)
-			{
-				leaf = (mleaf_t *)p->nodes[i];
-				for (j = 0;j < p->numpoints;j++)
-				{
-					if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
-					if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
-					if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
-					if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
-					if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
-					if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
-				}
-			}
-		}
-		p = p->chain;
-	}
-
-	Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
-
-	// tally up portal and point counts
-	p = portalchain;
 	numportals = 0;
 	numpoints = 0;
 	while (p)
@@ -2452,9 +2518,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 *)((unsigned char *) 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++)
@@ -2468,59 +2534,78 @@ static void Mod_Q1BSP_FinalizePortals(void)
 	{
 		pnext = p->chain;
 
-		// note: this check must match the one above or it will usually corrupt memory
-		// the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
-		if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
+		if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
 		{
-			// first make the back to front portal(forward portal)
-			portal->points = point;
-			portal->numpoints = p->numpoints;
-			portal->plane.dist = p->plane.dist;
-			VectorCopy(p->plane.normal, portal->plane.normal);
-			portal->here = (mleaf_t *)p->nodes[1];
-			portal->past = (mleaf_t *)p->nodes[0];
-			// copy points
-			for (j = 0;j < portal->numpoints;j++)
+			// note: this check must match the one above or it will usually corrupt memory
+			// the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
+			if (((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
 			{
-				VectorCopy(p->points + j*3, point->position);
-				point++;
+				// first make the back to front portal(forward portal)
+				portal->points = point;
+				portal->numpoints = p->numpoints;
+				portal->plane.dist = p->plane.dist;
+				VectorCopy(p->plane.normal, portal->plane.normal);
+				portal->here = (mleaf_t *)p->nodes[1];
+				portal->past = (mleaf_t *)p->nodes[0];
+				// copy points
+				for (j = 0;j < portal->numpoints;j++)
+				{
+					VectorCopy(p->points + j*3, point->position);
+					point++;
+				}
+				BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+				PlaneClassify(&portal->plane);
+
+				// link into leaf's portal chain
+				portal->next = portal->here->portals;
+				portal->here->portals = portal;
+
+				// advance to next portal
+				portal++;
+
+				// then make the front to back portal(backward portal)
+				portal->points = point;
+				portal->numpoints = p->numpoints;
+				portal->plane.dist = -p->plane.dist;
+				VectorNegate(p->plane.normal, portal->plane.normal);
+				portal->here = (mleaf_t *)p->nodes[0];
+				portal->past = (mleaf_t *)p->nodes[1];
+				// copy points
+				for (j = portal->numpoints - 1;j >= 0;j--)
+				{
+					VectorCopy(p->points + j*3, point->position);
+					point++;
+				}
+				BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+				PlaneClassify(&portal->plane);
+
+				// link into leaf's portal chain
+				portal->next = portal->here->portals;
+				portal->here->portals = portal;
+
+				// advance to next portal
+				portal++;
 			}
-			BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
-			PlaneClassify(&portal->plane);
-
-			// link into leaf's portal chain
-			portal->next = portal->here->portals;
-			portal->here->portals = portal;
-
-			// advance to next portal
-			portal++;
-
-			// then make the front to back portal(backward portal)
-			portal->points = point;
-			portal->numpoints = p->numpoints;
-			portal->plane.dist = -p->plane.dist;
-			VectorNegate(p->plane.normal, portal->plane.normal);
-			portal->here = (mleaf_t *)p->nodes[0];
-			portal->past = (mleaf_t *)p->nodes[1];
-			// copy points
-			for (j = portal->numpoints - 1;j >= 0;j--)
+			// add the portal's polygon points to the leaf bounding boxes
+			for (i = 0;i < 2;i++)
 			{
-				VectorCopy(p->points + j*3, point->position);
-				point++;
+				leaf = (mleaf_t *)p->nodes[i];
+				for (j = 0;j < p->numpoints;j++)
+				{
+					if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
+					if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
+					if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
+					if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
+					if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
+					if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
+				}
 			}
-			BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
-			PlaneClassify(&portal->plane);
-
-			// link into leaf's portal chain
-			portal->next = portal->here->portals;
-			portal->here->portals = portal;
-
-			// advance to next portal
-			portal++;
 		}
 		FreePortal(p);
 		p = pnext;
 	}
+	// now recalculate the node bounding boxes from the leafs
+	Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
 }
 
 /*
@@ -2565,7 +2650,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");
 
@@ -2642,7 +2727,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
 
 		for (i = 0;i < nodeportal->numpoints*3;i++)
 			frontpoints[i] = nodeportal->points[i];
-		PolygonD_Divide(nodeportal->numpoints, frontpoints, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, 1.0/32.0, MAX_PORTALPOINTS, nodeportal->points, &nodeportal->numpoints, 0, NULL, NULL);
+		PolygonD_Divide(nodeportal->numpoints, frontpoints, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, 1.0/32.0, MAX_PORTALPOINTS, nodeportal->points, &nodeportal->numpoints, 0, NULL, NULL, NULL);
 		if (nodeportal->numpoints <= 0 || nodeportal->numpoints >= MAX_PORTALPOINTS)
 			break;
 	}
@@ -2680,7 +2765,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
 		RemovePortalFromNodes(portal);
 
 		// cut the portal into two portals, one on each side of the node plane
-		PolygonD_Divide(portal->numpoints, portal->points, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, 1.0/32.0, MAX_PORTALPOINTS, frontpoints, &numfrontpoints, MAX_PORTALPOINTS, backpoints, &numbackpoints);
+		PolygonD_Divide(portal->numpoints, portal->points, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, 1.0/32.0, MAX_PORTALPOINTS, frontpoints, &numfrontpoints, MAX_PORTALPOINTS, backpoints, &numbackpoints, NULL);
 
 		if (!numfrontpoints)
 		{
@@ -2757,10 +2842,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 = (unsigned char *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(unsigned char));
+	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])
@@ -2789,10 +2874,9 @@ static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *mod
 
 //Returns PVS data for a given point
 //(note: can return NULL)
-static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
+static unsigned char *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];
@@ -2802,7 +2886,7 @@ static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
 		return NULL;
 }
 
-static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbytes, mnode_t *node)
+static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
 {
 	while (node->plane)
 	{
@@ -2822,7 +2906,7 @@ static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org,
 	if (((mleaf_t *)node)->clusterindex >= 0)
 	{
 		int i;
-		qbyte *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
+		unsigned char *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
 		for (i = 0;i < pvsbytes;i++)
 			pvsbuffer[i] |= pvs[i];
 	}
@@ -2830,7 +2914,7 @@ static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org,
 
 //Calculates a PVS that is the inclusive or of all leafs within radius pixels
 //of the given point.
-static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
+static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength)
 {
 	int bytes = model->brush.num_pvsclusterbytes;
 	bytes = min(bytes, pvsbufferlength);
@@ -2900,18 +2984,18 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
 	mod->type = mod_brushq1;
 
-	if (!memcmp (buffer, "MCBSP", 5))
+	if (!memcmp (buffer, "MCBSPpad", 8))
 	{
-		qbyte	*index;
+		unsigned char	*index;
 
 		mod->brush.ismcbsp = true;
 		mod->brush.ishlbsp = false;
 
-		mod_base = (qbyte*)buffer;
+		mod_base = (unsigned char*)buffer;
 
 		index = mod_base;
-		index += 5;
-		i = LittleLong(*(int*)index); index += 4;
+		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);
 
@@ -2922,20 +3006,20 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		VectorClear (hullinfo.hullsizes[0][1]);
 		for (i = 1; i < hullinfo.numhulls; i++)
 		{
-			hullinfo.hullsizes[i][0][0] = LittleFloat(*(float*)index); index += 4;
-			hullinfo.hullsizes[i][0][1] = LittleFloat(*(float*)index); index += 4;
-			hullinfo.hullsizes[i][0][2] = LittleFloat(*(float*)index); index += 4;
-			hullinfo.hullsizes[i][1][0] = LittleFloat(*(float*)index); index += 4;
-			hullinfo.hullsizes[i][1][1] = LittleFloat(*(float*)index); index += 4;
-			hullinfo.hullsizes[i][1][2] = LittleFloat(*(float*)index); index += 4;
+			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 = LittleLong(*(int*)index); index += 4;
-			_header.lumps[i].filelen = LittleLong(*(int*)index); index += 4;
+			_header.lumps[i].fileofs = SB_ReadInt (&index);
+			_header.lumps[i].filelen = SB_ReadInt (&index);
 		}
 
 		header = &_header;
@@ -2957,25 +3041,25 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		{
 			hullinfo.numhulls = 4;
 			hullinfo.filehulls = 4;
-			VectorSet (hullinfo.hullsizes[0][0], -16, -16, -36);
-			VectorSet (hullinfo.hullsizes[0][1], 16, 16, 36);
-			VectorSet (hullinfo.hullsizes[1][0], -32, -32, -32);
-			VectorSet (hullinfo.hullsizes[1][1], 32, 32, 32);
-			VectorSet (hullinfo.hullsizes[2][0], -16, -16, -18);
-			VectorSet (hullinfo.hullsizes[2][1], 16, 16, 18);
+			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[0][0], -16, -16, -24);
-			VectorSet (hullinfo.hullsizes[0][1], 16, 16, 32);
-			VectorSet (hullinfo.hullsizes[1][0], -32, -32, -24);
-			VectorSet (hullinfo.hullsizes[1][1], 32, 32, 64);
+			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;
+		mod_base = (unsigned char*)buffer;
 		for (i = 0; i < HEADER_LUMPS; i++)
 		{
 			header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
@@ -2992,6 +3076,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;
@@ -3009,6 +3094,18 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	// store which lightmap format to use
 	mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
 
+	mod->brush.qw_md4sum = 0;
+	mod->brush.qw_md4sum2 = 0;
+	for (i = 0;i < HEADER_LUMPS;i++)
+	{
+		if (i == LUMP_ENTITIES)
+			continue;
+		mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
+		if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
+			continue;
+		mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
+	}
+
 	Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]);
 	Mod_Q1BSP_LoadVertexes(&header->lumps[LUMP_VERTEXES]);
 	Mod_Q1BSP_LoadEdges(&header->lumps[LUMP_EDGES]);
@@ -3042,8 +3139,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
 	mainmempool = mod->mempool;
 
-	Mod_Q1BSP_LoadLightList();
-
 	// make a single combined shadow mesh to allow optimized shadow volume creation
 	numshadowmeshtriangles = 0;
 	for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
@@ -3058,7 +3153,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)
 	{
@@ -3125,7 +3220,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;
 
@@ -3143,6 +3238,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;
 		}
@@ -3585,7 +3681,7 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	int i;
 	q2dheader_t *header;
 
-	Host_Error("Mod_Q2BSP_Load: not yet implemented\n");
+	Host_Error("Mod_Q2BSP_Load: not yet implemented");
 
 	mod->type = mod_brushq2;
 
@@ -3602,7 +3698,7 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
 	}
 
-	mod_base = (qbyte *)header;
+	mod_base = (unsigned char *)header;
 
 	// swap all the lumps
 	for (i = 0;i < (int) sizeof(*header) / 4;i++)
@@ -3611,6 +3707,18 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	// store which lightmap format to use
 	mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
 
+	mod->brush.qw_md4sum = 0;
+	mod->brush.qw_md4sum2 = 0;
+	for (i = 0;i < Q2HEADER_LUMPS;i++)
+	{
+		if (i == Q2LUMP_ENTITIES)
+			continue;
+		mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+		if (i == Q2LUMP_VISIBILITY || i == Q2LUMP_LEAFS || i == Q2LUMP_NODES)
+			continue;
+		mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+	}
+
 	Mod_Q2BSP_LoadEntities(&header->lumps[Q2LUMP_ENTITIES]);
 	Mod_Q2BSP_LoadPlanes(&header->lumps[Q2LUMP_PLANES]);
 	Mod_Q2BSP_LoadVertices(&header->lumps[Q2LUMP_VERTEXES]);
@@ -3638,14 +3746,14 @@ static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int superco
 static void Mod_Q3BSP_LoadEntities(lump_t *l)
 {
 	const char *data;
-	char key[128], value[4096];
+	char key[128], value[MAX_INPUTLINE];
 	float v[3];
 	loadmodel->brushq3.num_lightgrid_cellsize[0] = 64;
 	loadmodel->brushq3.num_lightgrid_cellsize[1] = 64;
 	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
@@ -3690,11 +3798,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;
@@ -3712,7 +3820,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, NULL)))
 			{
 				text = f;
 				while (COM_ParseToken(&text, false))
@@ -3962,9 +4070,9 @@ 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, 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)
+		if (cls.state != ca_dedicated)
+			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))
 					Con_Printf("%s: texture loading for shader \"%s\" failed (first layer \"%s\" not found either)\n", loadmodel->name, out->name, out->firstpasstexturename);
 		// no animation
 		out->currentframe = out;
@@ -3979,11 +4087,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;
@@ -4004,11 +4112,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;
@@ -4017,11 +4125,11 @@ static void Mod_Q3BSP_LoadBrushSides(lump_t *l)
 	{
 		n = LittleLong(in->planeindex);
 		if (n < 0 || n >= loadmodel->brush.num_planes)
-			Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)\n", n, loadmodel->brush.num_planes);
+			Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
 		out->plane = loadmodel->brush.data_planes + n;
 		n = LittleLong(in->textureindex);
 		if (n < 0 || n >= loadmodel->num_textures)
-			Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)\n", n, loadmodel->num_textures);
+			Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
 		out->texture = loadmodel->data_textures + n;
 	}
 }
@@ -4033,11 +4141,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;
@@ -4050,12 +4158,12 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l)
 		n = LittleLong(in->firstbrushside);
 		c = LittleLong(in->numbrushsides);
 		if (n < 0 || n + c > loadmodel->brush.num_brushsides)
-			Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)\n", n, n + c, loadmodel->brush.num_brushsides);
+			Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)", n, n + c, loadmodel->brush.num_brushsides);
 		out->firstbrushside = loadmodel->brush.data_brushsides + n;
 		out->numbrushsides = c;
 		n = LittleLong(in->textureindex);
 		if (n < 0 || n >= loadmodel->num_textures)
-			Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)\n", n, loadmodel->num_textures);
+			Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
 		out->texture = loadmodel->data_textures + n;
 
 		// make a list of mplane_t structs to construct a colbrush from
@@ -4064,7 +4172,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++)
 		{
@@ -4084,11 +4192,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;
@@ -4112,11 +4220,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;
@@ -4144,11 +4252,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;
@@ -4172,11 +4280,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;
@@ -4202,11 +4310,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;
@@ -4439,8 +4547,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);
@@ -4511,7 +4619,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);
 	}
 
@@ -4534,11 +4642,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;
@@ -4553,13 +4661,13 @@ static void Mod_Q3BSP_LoadModels(lump_t *l)
 		n = LittleLong(in->firstface);
 		c = LittleLong(in->numfaces);
 		if (n < 0 || n + c > loadmodel->num_surfaces)
-			Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)\n", n, n + c, loadmodel->num_surfaces);
+			Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)", n, n + c, loadmodel->num_surfaces);
 		out->firstface = n;
 		out->numfaces = c;
 		n = LittleLong(in->firstbrush);
 		c = LittleLong(in->numbrushes);
 		if (n < 0 || n + c > loadmodel->brush.num_brushes)
-			Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)\n", n, n + c, loadmodel->brush.num_brushes);
+			Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)", n, n + c, loadmodel->brush.num_brushes);
 		out->firstbrush = n;
 		out->numbrushes = c;
 	}
@@ -4571,11 +4679,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;
@@ -4584,7 +4692,7 @@ static void Mod_Q3BSP_LoadLeafBrushes(lump_t *l)
 	{
 		n = LittleLong(*in);
 		if (n < 0 || n >= loadmodel->brush.num_brushes)
-			Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
+			Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)", n, loadmodel->brush.num_brushes);
 		*out = n;
 	}
 }
@@ -4595,11 +4703,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;
@@ -4608,7 +4716,7 @@ static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
 	{
 		n = LittleLong(*in);
 		if (n < 0 || n >= loadmodel->num_surfaces)
-			Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->num_surfaces);
+			Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)", n, loadmodel->num_surfaces);
 		*out = n;
 	}
 }
@@ -4619,11 +4727,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;
@@ -4643,13 +4751,13 @@ static void Mod_Q3BSP_LoadLeafs(lump_t *l)
 		n = LittleLong(in->firstleafface);
 		c = LittleLong(in->numleaffaces);
 		if (n < 0 || n + c > loadmodel->brush.num_leafsurfaces)
-			Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafsurface range %i : %i (%i leafsurfaces)\n", n, n + c, loadmodel->brush.num_leafsurfaces);
+			Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafsurface range %i : %i (%i leafsurfaces)", n, n + c, loadmodel->brush.num_leafsurfaces);
 		out->firstleafsurface = loadmodel->brush.data_leafsurfaces + n;
 		out->numleafsurfaces = c;
 		n = LittleLong(in->firstleafbrush);
 		c = LittleLong(in->numleafbrushes);
 		if (n < 0 || n + c > loadmodel->brush.num_leafbrushes)
-			Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)\n", n, n + c, loadmodel->brush.num_leafbrushes);
+			Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)", n, n + c, loadmodel->brush.num_leafbrushes);
 		out->firstleafbrush = loadmodel->brush.data_leafbrushes + n;
 		out->numleafbrushes = c;
 	}
@@ -4661,11 +4769,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;
@@ -4675,7 +4783,7 @@ static void Mod_Q3BSP_LoadNodes(lump_t *l)
 		out->parent = NULL;
 		n = LittleLong(in->planeindex);
 		if (n < 0 || n >= loadmodel->brush.num_planes)
-			Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)\n", n, loadmodel->brush.num_planes);
+			Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
 		out->plane = loadmodel->brush.data_planes + n;
 		for (j = 0;j < 2;j++)
 		{
@@ -4683,14 +4791,14 @@ static void Mod_Q3BSP_LoadNodes(lump_t *l)
 			if (n >= 0)
 			{
 				if (n >= loadmodel->brush.num_nodes)
-					Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)\n", n, loadmodel->brush.num_nodes);
+					Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)", n, loadmodel->brush.num_nodes);
 				out->children[j] = loadmodel->brush.data_nodes + n;
 			}
 			else
 			{
 				n = -1 - n;
 				if (n >= loadmodel->brush.num_leafs)
-					Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)\n", n, loadmodel->brush.num_leafs);
+					Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)", n, loadmodel->brush.num_leafs);
 				out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + n);
 			}
 		}
@@ -4712,7 +4820,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];
@@ -4735,10 +4843,10 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
 	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]);
+			Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", 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));
+			Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i", count * sizeof(*in), 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
@@ -4763,25 +4871,25 @@ 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);
 
 	loadmodel->brush.num_pvsclusters = LittleLong(in->numclusters);
 	loadmodel->brush.num_pvsclusterbytes = LittleLong(in->chainlength);
 	if (loadmodel->brush.num_pvsclusterbytes < ((loadmodel->brush.num_pvsclusters + 7) / 8))
-		Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8\n", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters);
+		Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters);
 	totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
 	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);
+		Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, totalchains + sizeof(*in), l->filelen);
 
-	loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
-	memcpy(loadmodel->brush.data_pvsclusters, (qbyte *)(in + 1), totalchains);
+	loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
+	memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains);
 }
 
 static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
@@ -4869,51 +4977,54 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model,
 	float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
 	mleaf_t *leaf;
 	msurface_t *surface;
+	mplane_t *plane;
 	colbrushf_t *brush;
-	if (startfrac > trace->realfraction)
-		return;
-	// note: all line fragments past first impact fraction are ignored
-	if (VectorCompare(start, end))
-	{
-		// find which leaf the point is in
-		while (node->plane)
-			node = node->children[DotProduct(start, node->plane->normal) < node->plane->dist];
-	}
-	else
+	// walk the tree until we hit a leaf, recursing for any split cases
+	while (node->plane)
 	{
-		// find which nodes the line is in and recurse for them
-		while (node->plane)
+		plane = node->plane;
+		// axial planes are much more common than non-axial, so an optimized
+		// axial case pays off here
+		if (plane->type < 3)
 		{
-			// recurse down node sides
-			dist1 = PlaneDiff(start, node->plane);
-			dist2 = PlaneDiff(end, node->plane);
-			startside = dist1 < 0;
-			endside = dist2 < 0;
-			if (startside == endside)
-			{
-				// most of the time the line fragment is on one side of the plane
-				node = node->children[startside];
-			}
-			else
-			{
-				// line crosses node plane, split the line
-				midfrac = dist1 / (dist1 - dist2);
-				VectorLerp(start, midfrac, end, mid);
-				// take the near side first
-				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-				if (midfrac <= trace->realfraction)
-					Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-				return;
-			}
+			dist1 = start[plane->type] - plane->dist;
+			dist2 = end[plane->type] - plane->dist;
+		}
+		else
+		{
+			dist1 = DotProduct(start, plane->normal) - plane->dist;
+			dist2 = DotProduct(end, plane->normal) - plane->dist;
+		}
+		startside = dist1 < 0;
+		endside = dist2 < 0;
+		if (startside == endside)
+		{
+			// most of the time the line fragment is on one side of the plane
+			node = node->children[startside];
+		}
+		else
+		{
+			// line crosses node plane, split the line
+			dist1 = PlaneDiff(linestart, plane);
+			dist2 = PlaneDiff(lineend, plane);
+			midfrac = dist1 / (dist1 - dist2);
+			VectorLerp(linestart, midfrac, lineend, mid);
+			// take the near side first
+			Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+			// if we found an impact on the front side, don't waste time
+			// exploring the far side
+			if (midfrac <= trace->realfraction)
+				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+			return;
 		}
 	}
 	// hit a leaf
-	nodesegmentmins[0] = min(start[0], end[0]);
-	nodesegmentmins[1] = min(start[1], end[1]);
-	nodesegmentmins[2] = min(start[2], end[2]);
-	nodesegmentmaxs[0] = max(start[0], end[0]);
-	nodesegmentmaxs[1] = max(start[1], end[1]);
-	nodesegmentmaxs[2] = max(start[2], end[2]);
+	nodesegmentmins[0] = min(start[0], end[0]) - 1;
+	nodesegmentmins[1] = min(start[1], end[1]) - 1;
+	nodesegmentmins[2] = min(start[2], end[2]) - 1;
+	nodesegmentmaxs[0] = max(start[0], end[0]) + 1;
+	nodesegmentmaxs[1] = max(start[1], end[1]) + 1;
+	nodesegmentmaxs[2] = max(start[2], end[2]) + 1;
 	// line trace the brushes
 	leaf = (mleaf_t *)node;
 	for (i = 0;i < leaf->numleafbrushes;i++)
@@ -4923,8 +5034,6 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model,
 		{
 			brush->markframe = markframe;
 			Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
-			if (startfrac > trace->realfraction)
-				return;
 		}
 	}
 	// can't do point traces on curves (they have no thickness)
@@ -4938,8 +5047,6 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model,
 			{
 				surface->collisionmarkframe = markframe;
 				Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
-				if (startfrac > trace->realfraction)
-					return;
 			}
 		}
 	}
@@ -4948,356 +5055,53 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model,
 static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
 {
 	int i;
-	//int sides;
-	float nodesegmentmins[3], nodesegmentmaxs[3];
+	int sides;
 	mleaf_t *leaf;
 	colbrushf_t *brush;
 	msurface_t *surface;
-	/*
-		// find which nodes the line is in and recurse for them
-		while (node->plane)
-		{
-			// recurse down node sides
-			int startside, endside;
-			float dist1near, dist1far, dist2near, dist2far;
-			BoxPlaneCornerDistances(thisbrush_start->mins, thisbrush_start->maxs, node->plane, &dist1near, &dist1far);
-			BoxPlaneCornerDistances(thisbrush_end->mins, thisbrush_end->maxs, node->plane, &dist2near, &dist2far);
-			startside = dist1near < 0;
-			startside = dist1near < 0 ? (dist1far < 0 ? 1 : 2) : (dist1far < 0 ? 2 : 0);
-			endside = dist2near < 0 ? (dist2far < 0 ? 1 : 2) : (dist2far < 0 ? 2 : 0);
-			if (startside == 2 || endside == 2)
-			{
-				// brushes cross plane
-				// do not clip anything, just take both sides
-				Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-				node = node->children[1];
-				continue;
-			}
-			if (startside == 0)
-			{
-				if (endside == 0)
-				{
-					node = node->children[0];
-					continue;
-				}
-				else
-				{
-					//midf0 = dist1near / (dist1near - dist2near);
-					//midf1 = dist1far / (dist1far - dist2far);
-					Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-					node = node->children[1];
-					continue;
-				}
-			}
-			else
-			{
-				if (endside == 0)
-				{
-					//midf0 = dist1near / (dist1near - dist2near);
-					//midf1 = dist1far / (dist1far - dist2far);
-					Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-					node = node->children[1];
-					continue;
-				}
-				else
-				{
-					node = node->children[1];
-					continue;
-				}
-			}
-
-			if (dist1near <  0 && dist2near <  0 && dist1far <  0 && dist2far <  0){node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near <  0 && dist1far <  0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near <  0 && dist1far >= 0 && dist2far <  0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near <  0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near >= 0 && dist1far <  0 && dist2far <  0){node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near >= 0 && dist1far <  0 && dist2far >= 0){}
-			if (dist1near <  0 && dist2near >= 0 && dist1far >= 0 && dist2far <  0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near <  0 && dist2near >= 0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near >= 0 && dist2near <  0 && dist1far <  0 && dist2far <  0){node = node->children[1];continue;}
-			if (dist1near >= 0 && dist2near <  0 && dist1far <  0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near >= 0 && dist2near <  0 && dist1far >= 0 && dist2far <  0){}
-			if (dist1near >= 0 && dist2near <  0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near >= 0 && dist2near >= 0 && dist1far <  0 && dist2far <  0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
-			if (dist1near >= 0 && dist2near >= 0 && dist1far <  0 && dist2far >= 0){node = node->children[0];continue;}
-			if (dist1near >= 0 && dist2near >= 0 && dist1far >= 0 && dist2far <  0){node = node->children[0];continue;}
-			if (dist1near >= 0 && dist2near >= 0 && dist1far >= 0 && dist2far >= 0){node = node->children[0];continue;}
-			{
-				if (dist2near < 0) // d1n<0 && d2n<0
-				{
-					if (dist2near < 0) // d1n<0 && d2n<0
-					{
-						if (dist2near < 0) // d1n<0 && d2n<0
-						{
-						}
-						else // d1n<0 && d2n>0
-						{
-						}
-					}
-					else // d1n<0 && d2n>0
-					{
-						if (dist2near < 0) // d1n<0 && d2n<0
-						{
-						}
-						else // d1n<0 && d2n>0
-						{
-						}
-					}
-				}
-				else // d1n<0 && d2n>0
-				{
-				}
-			}
-			else // d1n>0
-			{
-				if (dist2near < 0) // d1n>0 && d2n<0
-				{
-				}
-				else // d1n>0 && d2n>0
-				{
-				}
-			}
-			if (dist1near < 0 == dist1far < 0 == dist2near < 0 == dist2far < 0)
-			{
-				node = node->children[startside];
-				continue;
-			}
-			if (dist1near < dist2near)
-			{
-				// out
-				if (dist1near >= 0)
-				{
-					node = node->children[0];
-					continue;
-				}
-				if (dist2far < 0)
-				{
-					node = node->children[1];
-					continue;
-				}
-				// dist1near < 0 && dist2far >= 0
-			}
-			else
-			{
-				// in
-			}
-			startside = dist1near < 0 ? (dist1far < 0 ? 1 : 2) : (dist1far < 0 ? 2 : 0);
-			endside = dist2near < 0 ? (dist2far < 0 ? 1 : 2) : (dist2far < 0 ? 2 : 0);
-			if (startside == 2 || endside == 2)
-			{
-				// brushes cross plane
-				// do not clip anything, just take both sides
-				Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-				node = node->children[1];
-			}
-			else if (startside == endside)
-				node = node->children[startside];
-			else if (startside == 0) // endside = 1 (start infront, end behind)
-			{
-			}
-			else // startside == 1 endside = 0 (start behind, end infront)
-			{
-			}
-			== endside)
-			{
-				if (startside < 2)
-					node = node->children[startside];
-				else
-				{
-					// start and end brush cross plane
-				}
-			}
-			else
-			{
-			}
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-				node = node->children[1];
-			else if (dist1near < 0 && dist1far < 0 && dist2near >= 0 && dist2far >= 0)
-			else if (dist1near >= 0 && dist1far >= 0 && dist2near < 0 && dist2far < 0)
-			else if (dist1near >= 0 && dist1far >= 0 && dist2near >= 0 && dist2far >= 0)
-				node = node->children[0];
-			else
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-			{
-			}
-			else if (dist1near >= 0 && dist1far >= 0)
-			{
-			}
-			else // mixed (lying on plane)
-			{
-			}
-			{
-				if (dist2near < 0 && dist2far < 0)
-				{
-				}
-				else
-					node = node->children[1];
-			}
-			if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
-				node = node->children[0];
-			else if (dist1near >= 0 && dist1far >= 0 && dist2near >= 0 && dist2far >= 0)
-				node = node->children[1];
-			else
-			{
-				// both sides
-				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-				node = node->children[1];
-			}
-			sides = dist1near || dist1near < 0 | dist1far < 0 | dist2near < 0 | dist
-			startside = dist1 < 0;
-			endside = dist2 < 0;
-			if (startside == endside)
-			{
-				// most of the time the line fragment is on one side of the plane
-				node = node->children[startside];
-			}
-			else
-			{
-				// line crosses node plane, split the line
-				midfrac = dist1 / (dist1 - dist2);
-				VectorLerp(start, midfrac, end, mid);
-				// take the near side first
-				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-				if (midfrac <= trace->fraction)
-					Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
-				return;
-			}
-		}
-	*/
-#if 1
-	for (;;)
-	{
-		nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
-		nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
-		nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
-		nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
-		nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
-		nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
-		if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
-			return;
-		if (!node->plane)
-			break;
-		Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-		node = node->children[1];
-	}
-#elif 0
-	// FIXME: could be made faster by copying TraceLine code and making it use
-	// box plane distances...  (variant on the BoxOnPlaneSide code)
-	for (;;)
+	mplane_t *plane;
+	float nodesegmentmins[3], nodesegmentmaxs[3];
+	// walk the tree until we hit a leaf, recursing for any split cases
+	while (node->plane)
 	{
-		nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
-		nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
-		nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
-		nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
-		nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
-		nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
-		if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
-			return;
-		if (!node->plane)
-			break;
-		if (mod_q3bsp_debugtracebrush.integer == 2)
-		{
-			Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-			node = node->children[1];
-			continue;
-		}
-		else if (mod_q3bsp_debugtracebrush.integer == 1)
+		plane = node->plane;
+		// axial planes are much more common than non-axial, so an optimized
+		// axial case pays off here
+		if (plane->type < 3)
 		{
+			// this is an axial plane, compare bounding box directly to it and
+			// recurse sides accordingly
 			// recurse down node sides
-			sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
-			if (sides == 3)
-			{
-				// segment box crosses plane
-				Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-				node = node->children[1];
-				continue;
-			}
-			// take whichever side the segment box is on
-			node = node->children[sides - 1];
-			continue;
+			// use an inlined axial BoxOnPlaneSide to slightly reduce overhead
+			//sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
+			//sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
+			sides = ((segmentmaxs[plane->type] >= plane->dist) + ((segmentmins[plane->type] < plane->dist) * 2));
 		}
 		else
 		{
-			// recurse down node sides
-			sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
-			if (sides == 3)
-			{
-				// segment box crosses plane
-				// now check start and end brush boxes to handle a lot of 'diagonal' cases more efficiently...
-				sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, node->plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, node->plane);
-				if (sides == 3)
-				{
-					Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-					node = node->children[1];
-					continue;
-				}
-			}
-			// take whichever side the segment box is on
-			node = node->children[sides - 1];
-			continue;
-		}
-		return;
-	}
-#else
-	// FIXME: could be made faster by copying TraceLine code and making it use
-	// box plane distances...  (variant on the BoxOnPlaneSide code)
-	for (;;)
-	{
-		nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
-		nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
-		nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
-		nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
-		nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
-		nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
-		if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
-			return;
-		if (!node->plane)
-			break;
-		if (mod_q3bsp_debugtracebrush.integer == 2)
-		{
-			Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-			node = node->children[1];
+			// this is a non-axial plane, so check if the start and end boxes
+			// are both on one side of the plane to handle 'diagonal' cases
+			sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
 		}
-		else if (mod_q3bsp_debugtracebrush.integer == 1)
+		if (sides == 3)
 		{
-			// recurse down node sides
-			sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
-			if (sides == 3)
-			{
-				// segment box crosses plane
-				Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-				node = node->children[1];
-			}
-			else
-			{
-				// take whichever side the segment box is on
-				node = node->children[sides - 1];
-			}
-		}
-		else
-		{
-			// recurse down node sides
-			sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
-			if (sides == 3)
-			{
-				// segment box crosses plane
-				// now check start and end brush boxes to handle a lot of 'diagonal' cases more efficiently...
-				sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, node->plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, node->plane);
-				if (sides == 3)
-				{
-					Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
-					sides = 2;
-				}
-			}
-			// take whichever side the segment box is on
-			node = node->children[sides - 1];
+			// segment crosses plane
+			Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+			sides = 2;
 		}
-	}
-#endif
+		// if sides == 0 then the trace itself is bogus (Not A Number values),
+		// in this case we simply pretend the trace hit nothing
+		if (sides == 0)
+			return; // ERROR: NAN bounding box!
+		// take whichever side the segment box is on
+		node = node->children[sides - 1];
+	}
+	nodesegmentmins[0] = max(segmentmins[0], node->mins[0] - 1);
+	nodesegmentmins[1] = max(segmentmins[1], node->mins[1] - 1);
+	nodesegmentmins[2] = max(segmentmins[2], node->mins[2] - 1);
+	nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0] + 1);
+	nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1] + 1);
+	nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2] + 1);
 	// hit a leaf
 	leaf = (mleaf_t *)node;
 	for (i = 0;i < leaf->numleafbrushes;i++)
@@ -5323,12 +5127,10 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model
 	}
 }
 
-static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t boxstartmins, const vec3_t boxstartmaxs, const vec3_t boxendmins, const vec3_t boxendmaxs, int hitsupercontentsmask)
+static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
 {
 	int i;
 	float segmentmins[3], segmentmaxs[3];
-	colbrushf_t *thisbrush_start, *thisbrush_end;
-	matrix4x4_t startmatrix, endmatrix;
 	static int markframe = 0;
 	msurface_t *surface;
 	q3mbrush_t *brush;
@@ -5336,50 +5138,60 @@ static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const
 	trace->fraction = 1;
 	trace->realfraction = 1;
 	trace->hitsupercontentsmask = hitsupercontentsmask;
-	Matrix4x4_CreateIdentity(&startmatrix);
-	Matrix4x4_CreateIdentity(&endmatrix);
-	segmentmins[0] = min(boxstartmins[0], boxendmins[0]);
-	segmentmins[1] = min(boxstartmins[1], boxendmins[1]);
-	segmentmins[2] = min(boxstartmins[2], boxendmins[2]);
-	segmentmaxs[0] = max(boxstartmaxs[0], boxendmaxs[0]);
-	segmentmaxs[1] = max(boxstartmaxs[1], boxendmaxs[1]);
-	segmentmaxs[2] = max(boxstartmaxs[2], boxendmaxs[2]);
-	if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxstartmins, boxstartmaxs) && VectorCompare(boxendmins, boxendmaxs))
-	{
-		if (VectorCompare(boxstartmins, boxendmins))
+	if (mod_q3bsp_optimizedtraceline.integer && VectorLength2(boxmins) + VectorLength2(boxmaxs) == 0)
+	{
+		if (VectorCompare(start, end))
 		{
 			// point trace
 			if (model->brush.submodel)
 			{
 				for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 					if (brush->colbrushf)
-						Collision_TracePointBrushFloat(trace, boxstartmins, brush->colbrushf);
+						Collision_TracePointBrushFloat(trace, start, brush->colbrushf);
 			}
 			else
-				Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, ++markframe);
+				Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe);
 		}
 		else
 		{
 			// line trace
+			segmentmins[0] = min(start[0], end[0]) - 1;
+			segmentmins[1] = min(start[1], end[1]) - 1;
+			segmentmins[2] = min(start[2], end[2]) - 1;
+			segmentmaxs[0] = max(start[0], end[0]) + 1;
+			segmentmaxs[1] = max(start[1], end[1]) + 1;
+			segmentmaxs[2] = max(start[2], end[2]) + 1;
 			if (model->brush.submodel)
 			{
 				for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 					if (brush->colbrushf)
-						Collision_TraceLineBrushFloat(trace, boxstartmins, boxendmins, brush->colbrushf, brush->colbrushf);
+						Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf);
 				if (mod_q3bsp_curves_collisions.integer)
 					for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
 						if (surface->num_collisiontriangles)
-							Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
+							Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
 			}
 			else
-				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, boxendmins, 0, 1, boxstartmins, boxendmins, ++markframe, segmentmins, segmentmaxs);
+				Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs);
 		}
 	}
 	else
 	{
 		// box trace, performed as brush trace
-		thisbrush_start = Collision_BrushForBox(&startmatrix, boxstartmins, boxstartmaxs);
-		thisbrush_end = Collision_BrushForBox(&endmatrix, boxendmins, boxendmaxs);
+		colbrushf_t *thisbrush_start, *thisbrush_end;
+		vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
+		segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
+		segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
+		segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
+		segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
+		segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
+		segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
+		VectorAdd(start, boxmins, boxstartmins);
+		VectorAdd(start, boxmaxs, boxstartmaxs);
+		VectorAdd(end, boxmins, boxendmins);
+		VectorAdd(end, boxmaxs, boxendmaxs);
+		thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs);
+		thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs);
 		if (model->brush.submodel)
 		{
 			for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
@@ -5493,6 +5305,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;
@@ -5502,7 +5315,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
 	mod->DrawLight = R_Q1BSP_DrawLight;
 
-	mod_base = (qbyte *)header;
+	mod_base = (unsigned char *)header;
 
 	// swap all the lumps
 	header->ident = LittleLong(header->ident);
@@ -5513,6 +5326,18 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
 	}
 
+	mod->brush.qw_md4sum = 0;
+	mod->brush.qw_md4sum2 = 0;
+	for (i = 0;i < Q3HEADER_LUMPS;i++)
+	{
+		if (i == Q3LUMP_ENTITIES)
+			continue;
+		mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+		if (i == Q3LUMP_PVS || i == Q3LUMP_LEAFS || i == Q3LUMP_NODES)
+			continue;
+		mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+	}
+
 	Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
 	Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
 	Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]);
@@ -5584,6 +5409,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;
 		}
@@ -5594,7 +5420,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;
 
@@ -5630,11 +5456,11 @@ void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
 	else if (i == Q2BSPVERSION)
 		Mod_Q2BSP_Load(mod,buffer, bufferend);
 	else
-		Host_Error("Mod_IBSP_Load: unknown/unsupported version %i\n", i);
+		Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
 }
 
 void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
 {
-	Host_Error("Mod_MAP_Load: not yet implemented\n");
+	Host_Error("Mod_MAP_Load: not yet implemented");
 }