X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=f652f221c134840744ce84dfddec467984e8ef46;hb=371c215e998e4d024a4f2ad613d73e6ce81b2675;hp=9402a6f7a50400ed93a683a955c799e527d7a30f;hpb=d5ea21772f2ee1609671ebd393a10f71892db483;p=xonotic%2Fdarkplaces.git

diff --git a/model_brush.c b/model_brush.c
index 9402a6f7..f652f221 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -27,22 +27,22 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 
 //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 r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
 cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"};
 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_mintess = {0, "r_subdivisions_mintess", "0", "minimum number of subdivisions (values above 0 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_mintess = {0, "r_subdivisions_collision_mintess", "0", "minimum number of subdivisions (values above 0 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)"};
 cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."};
+cvar_t mod_q3bsp_nolightmaps = {CVAR_SAVE, "mod_q3bsp_nolightmaps", "0", "do not load lightmaps in Q3BSP maps (to save video RAM, but be warned: it looks ugly)"};
 
 static texture_t mod_q1bsp_texture_solid;
 static texture_t mod_q1bsp_texture_sky;
@@ -53,7 +53,6 @@ static texture_t mod_q1bsp_texture_water;
 void Mod_BrushInit(void)
 {
 //	Cvar_RegisterVariable(&r_subdivide_size);
-	Cvar_RegisterVariable(&halflifebsp);
 	Cvar_RegisterVariable(&r_novis);
 	Cvar_RegisterVariable(&r_picmipworld);
 	Cvar_RegisterVariable(&r_nosurftextures);
@@ -69,6 +68,7 @@ void Mod_BrushInit(void)
 	Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
 	Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
 	Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
+	Cvar_RegisterVariable(&mod_q3bsp_nolightmaps);
 
 	memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
 	strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
@@ -96,7 +96,7 @@ void Mod_BrushInit(void)
 	mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER;
 }
 
-static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
+static mleaf_t *Mod_Q1BSP_PointInLeaf(dp_model_t *model, const vec3_t p)
 {
 	mnode_t *node;
 
@@ -112,7 +112,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, unsigned char *out, int outsize)
+static void Mod_Q1BSP_AmbientSoundLevelsForPoint(dp_model_t *model, const vec3_t p, unsigned char *out, int outsize)
 {
 	int i;
 	mleaf_t *leaf;
@@ -131,7 +131,7 @@ static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p,
 		memset(out, 0, outsize);
 }
 
-static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
+static int Mod_Q1BSP_FindBoxClusters(dp_model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
 {
 	int numclusters = 0;
 	int nodestackindex = 0;
@@ -197,7 +197,7 @@ static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const ve
 	return numclusters;
 }
 
-static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
 {
 	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
@@ -268,7 +268,7 @@ static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, co
 	return false;
 }
 
-static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingLeafPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
 {
 	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
@@ -339,7 +339,7 @@ static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs
 	return false;
 }
 
-static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(dp_model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
 {
 	int nodestackindex = 0;
 	mnode_t *node, *nodestack[1024];
@@ -414,7 +414,7 @@ typedef struct findnonsolidlocationinfo_s
 	vec_t radius;
 	vec3_t nudge;
 	vec_t bestdist;
-	model_t *model;
+	dp_model_t *model;
 }
 findnonsolidlocationinfo_t;
 
@@ -533,7 +533,7 @@ static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, m
 	}
 }
 
-static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius)
+static void Mod_Q1BSP_FindNonSolidLocation(dp_model_t *model, const vec3_t in, vec3_t out, float radius)
 {
 	int i;
 	findnonsolidlocationinfo_t info;
@@ -557,7 +557,7 @@ static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3
 	VectorCopy(info.center, out);
 }
 
-int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
+int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents)
 {
 	switch(nativecontents)
 	{
@@ -577,7 +577,7 @@ int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents
 	return 0;
 }
 
-int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
+int Mod_Q1BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents)
 {
 	if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))
 		return CONTENTS_SOLID;
@@ -885,7 +885,7 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 
 static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
 {
-	int num = 0;
+	int num = model->brushq1.hulls[0].firstclipnode;
 	mplane_t *plane;
 	mclipnode_t *nodes = model->brushq1.hulls[0].clipnodes;
 	mplane_t *planes = model->brushq1.hulls[0].planes;
@@ -1071,7 +1071,7 @@ static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t s
 	return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2;
 }
 
-static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
+static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(dp_model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
 {
 	int side;
 	float front, back;
@@ -1190,7 +1190,7 @@ loc0:
 	}
 }
 
-void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
+void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
 {
 	// pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction)
 	VectorSet(diffusenormal, 0, 0, 1);
@@ -1317,6 +1317,9 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 	unsigned char *data, *mtdata;
 	const char *s;
 	char mapname[MAX_QPATH], name[MAX_QPATH];
+	unsigned char zero[4];
+
+	memset(zero, 0, sizeof(zero));
 
 	loadmodel->data_textures = NULL;
 
@@ -1353,17 +1356,16 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			tx->skinframerate = 1;
 			tx->skinframes[0] = skinframe;
 			tx->currentskinframe = tx->skinframes[0];
-			tx->basematerialflags = 0;
 		}
+		tx->basematerialflags = MATERIALFLAG_WALL;
 		if (i == loadmodel->num_textures - 1)
 		{
-			tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+			tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
 			tx->supercontents = mod_q1bsp_texture_water.supercontents;
 			tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
 		}
 		else
 		{
-			tx->basematerialflags |= MATERIALFLAG_WALL;
 			tx->supercontents = mod_q1bsp_texture_solid.supercontents;
 			tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
 		}
@@ -1376,6 +1378,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		Vector4Set(tx->refractcolor4f, 1, 1, 1, 1);
 		tx->reflectfactor = 1;
 		Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1);
+		tx->r_water_wateralpha = 1;
 	}
 
 	if (!m)
@@ -1407,13 +1410,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 		// copy name, but only up to 16 characters
 		// (the output buffer can hold more than this, but the input buffer is
 		//  only 16)
-		for (j = 0;dmiptex->name[j] && j < 16;j++)
+		for (j = 0;j < 16 && dmiptex->name[j];j++)
 			name[j] = dmiptex->name[j];
 		name[j] = 0;
 
 		if (!name[0])
 		{
-			sprintf(name, "unnamed%i", i);
+			dpsnprintf(name, sizeof(name), "unnamed%i", i);
 			Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name);
 		}
 
@@ -1440,7 +1443,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			if (name[j] >= 'A' && name[j] <= 'Z')
 				name[j] += 'a' - 'A';
 
-		if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, true, false, false))
+		if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0))
 			continue;
 
 		tx = loadmodel->data_textures + i;
@@ -1482,23 +1485,20 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			// LordHavoc: HL sky textures are entirely different than quake
 			if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
 			{
-				if (loadmodel->isworldmodel)
+				data = loadimagepixelsbgra(tx->name, false, false);
+				if (data && image_width == 256 && image_height == 128)
 				{
-					data = loadimagepixelsbgra(tx->name, false, false);
-					if (data && image_width == 256 && image_height == 128)
-					{
-						R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
-						Mem_Free(data);
-					}
-					else if (mtdata != NULL)
-						R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
+					R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
+					Mem_Free(data);
 				}
+				else if (mtdata != NULL)
+					R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
 			}
 			else
 			{
-				skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+				skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
 				if (!skinframe)
-					skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+					skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
 				if (!skinframe)
 				{
 					// did not find external texture, load it from the bsp or wad3
@@ -1515,34 +1515,50 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 						{
 							tx->width = image_width;
 							tx->height = image_height;
-							skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
+							skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
 						}
 						if (freepixels)
 							Mem_Free(freepixels);
 					}
 					else if (mtdata) // texture included
-						skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
+						skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
 				}
 				// if skinframe is still NULL the "missing" texture will be used
 				if (skinframe)
 					tx->skinframes[0] = skinframe;
 			}
 
-			tx->basematerialflags = 0;
+			tx->basematerialflags = MATERIALFLAG_WALL;
 			if (tx->name[0] == '*')
 			{
 				// 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 | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERSHADER;
-				tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+				if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae
+				{
+					// replace the texture with transparent black
+					Vector4Set(zero, 128, 128, 128, 128);
+					tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_ALPHA, zero, 1, 1);
+					tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION;
+				}
+				else if (!strncmp(tx->name,"*lava",5)
+				 || !strncmp(tx->name,"*teleport",9)
+				 || !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
+					tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+				else
+					tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATERSHADER;
+				if (tx->skinframes[0] && tx->skinframes[0]->fog)
+					tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+			}
+			else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae
+			{
+				// replace the texture with black
+				tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1);
+				tx->basematerialflags |= MATERIALFLAG_REFLECTION;
 			}
 			else if (!strncmp(tx->name, "sky", 3))
-				tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
-			else
-				tx->basematerialflags |= MATERIALFLAG_WALL;
-			if (tx->skinframes[0] && tx->skinframes[0]->fog)
+				tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
+			else if (!strcmp(tx->name, "caulk"))
+				tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
+			else if (tx->skinframes[0] && tx->skinframes[0]->fog)
 				tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
 
 			// start out with no animation
@@ -1682,7 +1698,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 				i = LittleLong(((int *)data)[1]);
 				if (i == 1)
 				{
-					Con_DPrintf("loaded %s\n", litfilename);
+					if (developer_loading.integer)
+						Con_Printf("loaded %s\n", litfilename);
 					loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
 					memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8);
 					Mem_Free(data);
@@ -1694,7 +1711,8 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 							i = LittleLong(((int *)data)[1]);
 							if (i == 1)
 							{
-								Con_DPrintf("loaded %s\n", dlitfilename);
+								if (developer_loading.integer)
+									Con_Printf("loaded %s\n", dlitfilename);
 								loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
 								memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8);
 								loadmodel->brushq3.deluxemapping_modelspace = false;
@@ -1750,7 +1768,6 @@ static void Mod_Q1BSP_LoadVisibility(lump_t *l)
 static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 {
 	char key[128], value[4096];
-	char wadname[128];
 	int i, j, k;
 	if (!data)
 		return;
@@ -1792,9 +1809,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 						{
 							k = value[i];
 							value[i] = 0;
-							strlcpy(wadname, "textures/", sizeof(wadname));
-							strlcat(wadname, &value[j], sizeof(wadname));
-							W_LoadTextureWadFile(wadname, false);
+							W_LoadTextureWadFile(&value[j], false);
 							j = i+1;
 							if (!k)
 								break;
@@ -1811,8 +1826,9 @@ static void Mod_Q1BSP_LoadEntities(lump_t *l)
 	loadmodel->brush.entities = NULL;
 	if (!l->filelen)
 		return;
-	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
+	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1);
 	memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
+	loadmodel->brush.entities[l->filelen] = 0;
 	if (loadmodel->brush.ishlbsp)
 		Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
 }
@@ -1965,7 +1981,7 @@ static void Mod_Q1BSP_LoadTexinfo(lump_t *l)
 		{
 			// if texture chosen is NULL or the shader needs a lightmap,
 			// force to notexture water shader
-			if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
+			if (out->texture == NULL)
 				out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1);
 		}
 		else
@@ -2147,7 +2163,7 @@ struct alloc_lm_state
 static void init_alloc_lm_state (struct alloc_lm_state* state)
 {
 	int r;
-	
+
 	state->currentY = 0;
 	for (r = 0; r < MAX_SINGLE_LM_SIZE; r++)
 	{
@@ -2211,6 +2227,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
 	loadmodel->num_surfaces = count;
 
+	loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char));
+
 	totalverts = 0;
 	totaltris = 0;
 	for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
@@ -2324,7 +2342,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		{
 			surface->lightmapinfo->samples = NULL;
 			// give non-lightmapped water a 1x white lightmap
-			if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
+			if (surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
 			{
 				surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
 				surface->lightmapinfo->styles[0] = 0;
@@ -2358,7 +2376,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			// additionally this is used by the later code to see if a
 			// lightmap is needed on this surface (rather than duplicating the
 			// logic above)
-			surface->cached_dlight = true;
+			loadmodel->brushq1.lightmapupdateflags[surfacenum] = true;
 		}
 	}
 
@@ -2380,18 +2398,13 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
 		for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
 		{
-			int i, iu, iv, lightmapx, lightmapy;
+			int i, iu, iv, lightmapx = 0, lightmapy = 0;
 			float u, v, ubase, vbase, uscale, vscale;
-			
+
 			smax = surface->lightmapinfo->extents[0] >> 4;
 			tmax = surface->lightmapinfo->extents[1] >> 4;
 			ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
 			tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
-			
-			// stainmap for permanent marks on walls
-			surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
-			// clear to white
-			memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
 
 			if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
 			{
@@ -2429,7 +2442,36 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 			}
 
 		}
+
+		if (cl_stainmaps.integer)
+		{
+			// allocate stainmaps for permanent marks on walls
+			int stainmapsize = 0;
+			unsigned char *stainsamples = NULL;
+			for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
+			{
+				ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+				tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+				stainmapsize += ssize * tsize * 3;
+			}
+			// allocate and clear to white
+			stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, stainmapsize);
+			memset(stainsamples, 255, stainmapsize);
+			// assign pointers
+			for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
+			{
+				ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+				tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+				surface->lightmapinfo->stainsamples = stainsamples;
+				stainsamples += ssize * tsize * 3;
+			}
+		}
 	}
+
+	// generate ushort elements array if possible
+	if (loadmodel->surfmesh.data_element3s)
+		for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+			loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
 }
 
 static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
@@ -2602,11 +2644,14 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void)
 	int i, j;
 	mleaf_t *leaf;
 	const unsigned char *pvs;
+	// if there's no vis data, assume supported (because everything is visible all the time)
+	if (!loadmodel->brush.data_pvsclusters)
+		return true;
 	// check all liquid leafs to see if they can see into empty leafs, if any
 	// can we can assume this map supports r_wateralpha
 	for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++)
 	{
-		if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters))
+		if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && leaf->clusterindex >= 0)
 		{
 			pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes;
 			for (j = 0;j < loadmodel->brush.num_leafs;j++)
@@ -3235,7 +3280,7 @@ static void Mod_Q1BSP_MakePortals(void)
 
 //Returns PVS data for a given point
 //(note: can return NULL)
-static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
+static unsigned char *Mod_Q1BSP_GetPVS(dp_model_t *model, const vec3_t p)
 {
 	mnode_t *node;
 	node = model->brush.data_nodes;
@@ -3247,7 +3292,7 @@ static unsigned char *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, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
+static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
 {
 	while (node->plane)
 	{
@@ -3275,7 +3320,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, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge)
+static int Mod_Q1BSP_FatPVS(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge)
 {
 	int bytes = model->brush.num_pvsclusterbytes;
 	bytes = min(bytes, pvsbufferlength);
@@ -3290,7 +3335,7 @@ static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsi
 	return bytes;
 }
 
-static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
+static void Mod_Q1BSP_RoundUpToHullSize(dp_model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
 {
 	vec3_t size;
 	const hull_t *hull;
@@ -3323,13 +3368,13 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co
 	VectorAdd(inmins, hull->clip_size, outmaxs);
 }
 
-void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
 	int i, j, k;
 	dheader_t *header;
 	dmodel_t *bm;
 	mempool_t *mainmempool;
-	float dist, modelyawradius, modelradius, *vec;
+	float dist, modelyawradius, modelradius;
 	msurface_t *surface;
 	int numshadowmeshtriangles;
 	hullinfo_t hullinfo;
@@ -3397,9 +3442,13 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
 	mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
-
-	if (loadmodel->isworldmodel)
-		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
+	mod->Draw = R_Q1BSP_Draw;
+	mod->DrawDepth = R_Q1BSP_DrawDepth;
+	mod->DrawDebug = R_Q1BSP_DrawDebug;
+	mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+	mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+	mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+	mod->DrawLight = R_Q1BSP_DrawLight;
 
 // load into heap
 
@@ -3462,7 +3511,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 = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
+		loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *));
 
 	// LordHavoc: to clear the fog around the original quake submodel code, I
 	// will explain:
@@ -3505,21 +3554,26 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		if (i > 0)
 		{
 			char name[10];
-			// LordHavoc: only register submodels if it is the world
-			// (prevents external bsp models from replacing world submodels with
-			//  their own)
-			if (!loadmodel->isworldmodel)
-				continue;
 			// duplicate the basic information
-			sprintf(name, "*%i", i);
-			mod = Mod_FindName(name);
+			dpsnprintf(name, sizeof(name), "*%i", i);
+			mod = Mod_FindName(name, loadmodel->name);
 			// copy the base model to this one
 			*mod = *loadmodel;
 			// rename the clone back to its proper name
 			strlcpy(mod->name, name, sizeof(mod->name));
+			mod->brush.parentmodel = loadmodel;
 			// textures and memory belong to the main model
 			mod->texturepool = NULL;
 			mod->mempool = NULL;
+			mod->brush.TraceLineOfSight = NULL;
+			mod->brush.GetPVS = NULL;
+			mod->brush.FatPVS = NULL;
+			mod->brush.BoxTouchingPVS = NULL;
+			mod->brush.BoxTouchingLeafPVS = NULL;
+			mod->brush.BoxTouchingVisibleLeafs = NULL;
+			mod->brush.FindBoxClusters = NULL;
+			mod->brush.LightPoint = NULL;
+			mod->brush.AmbientSoundLevelsForPoint = NULL;
 		}
 
 		mod->brush.submodel = i;
@@ -3540,75 +3594,51 @@ 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 = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
-		for (j = 0;j < mod->nummodelsurfaces;j++)
-			mod->surfacelist[j] = mod->firstmodelsurface + j;
+		mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
+		Mod_MakeSortedSurfaces(mod);
+
+		// copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius
+		// (previously this code measured the radius of the vertices of surfaces in the submodel, but that broke submodels that contain only CLIP brushes, which do not produce surfaces)
+		VectorCopy(bm->mins, mod->normalmins);
+		VectorCopy(bm->maxs, mod->normalmaxs);
+		dist = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
+		modelyawradius = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
+		modelyawradius = dist*dist+modelyawradius*modelyawradius;
+		modelradius = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
+		modelradius = modelyawradius + modelradius * modelradius;
+		modelyawradius = sqrt(modelyawradius);
+		modelradius = sqrt(modelradius);
+		mod->yawmins[0] = mod->yawmins[1] = -modelyawradius;
+		mod->yawmins[2] = mod->normalmins[2];
+		mod->yawmaxs[0] = mod->yawmaxs[1] =  modelyawradius;
+		mod->yawmaxs[2] = mod->normalmaxs[2];
+		mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
+		mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] =  modelradius;
+		mod->radius = modelradius;
+		mod->radius2 = modelradius * modelradius;
 
 		// this gets altered below if sky or water is used
 		mod->DrawSky = NULL;
 		mod->DrawAddWaterPlanes = NULL;
-		mod->Draw = R_Q1BSP_Draw;
-		mod->DrawDepth = R_Q1BSP_DrawDepth;
-		mod->DrawDebug = R_Q1BSP_DrawDebug;
-		mod->GetLightInfo = R_Q1BSP_GetLightInfo;
-		mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
-		mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
-		mod->DrawLight = R_Q1BSP_DrawLight;
-		if (i != 0)
-		{
-			mod->brush.TraceLineOfSight = NULL;
-			mod->brush.GetPVS = NULL;
-			mod->brush.FatPVS = NULL;
-			mod->brush.BoxTouchingPVS = NULL;
-			mod->brush.BoxTouchingLeafPVS = NULL;
-			mod->brush.BoxTouchingVisibleLeafs = NULL;
-			mod->brush.FindBoxClusters = NULL;
-			mod->brush.LightPoint = NULL;
-			mod->brush.AmbientSoundLevelsForPoint = NULL;
-		}
+
+		// scan surfaces for sky and water and flag the submodel as possessing these features or not
+		// build lightstyle lists for quick marking of dirty lightmaps when lightstyles flicker
 		if (mod->nummodelsurfaces)
 		{
-			// LordHavoc: calculate bmodel bounding box rather than trusting what it says
-			mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
-			mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
-			modelyawradius = 0;
-			modelradius = 0;
 			for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
-			{
-				// we only need to have a drawsky function if it is used(usually only on world model)
 				if (surface->texture->basematerialflags & MATERIALFLAG_SKY)
-					mod->DrawSky = R_Q1BSP_DrawSky;
+					break;
+			if (j < mod->nummodelsurfaces)
+				mod->DrawSky = R_Q1BSP_DrawSky;
+
+			for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
 				if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
-					mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
-				// calculate bounding shapes
-				for (k = 0, vec = (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex);k < surface->num_vertices;k++, vec += 3)
-				{
-					if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
-					if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
-					if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
-					if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
-					if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
-					if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
-					dist = vec[0]*vec[0]+vec[1]*vec[1];
-					if (modelyawradius < dist)
-						modelyawradius = dist;
-					dist += vec[2]*vec[2];
-					if (modelradius < dist)
-						modelradius = dist;
-				}
-			}
-			modelyawradius = sqrt(modelyawradius);
-			modelradius = sqrt(modelradius);
-			mod->yawmins[0] = mod->yawmins[1] = - (mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius);
-			mod->yawmins[2] = mod->normalmins[2];
-			mod->yawmaxs[2] = mod->normalmaxs[2];
-			mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
-			mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
-			mod->radius = modelradius;
-			mod->radius2 = modelradius * modelradius;
+					break;
+			if (j < mod->nummodelsurfaces)
+				mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
 
 			// build lightstyle update chains
-			// (used to rapidly mark surface->cached_dlight on many surfaces
+			// (used to rapidly mark lightmapupdateflags on many surfaces
 			// when d_lightstylevalue changes)
 			memset(stylecounts, 0, sizeof(stylecounts));
 			for (k = 0;k < mod->nummodelsurfaces;k++)
@@ -4039,7 +4069,7 @@ static void Mod_Q2BSP_LoadModels(lump_t *l)
 */
 }
 
-void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void static Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
 	int i;
 	q2dheader_t *header;
@@ -4055,9 +4085,6 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	i = LittleLong(header->version);
 	if (i != Q2BSPVERSION)
 		Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
-	mod->brush.ishlbsp = false;
-	if (loadmodel->isworldmodel)
-		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
 
 	mod_base = (unsigned char *)header;
 
@@ -4098,8 +4125,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]);
 }
 
-static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents);
-static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents);
+static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents);
+static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents);
 
 static void Mod_Q3BSP_LoadEntities(lump_t *l)
 {
@@ -4111,8 +4138,9 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 	loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
 	if (!l->filelen)
 		return;
-	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
+	loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1);
 	memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
+	loadmodel->brush.entities[l->filelen] = 0;
 	data = loadmodel->brush.entities;
 	// some Q3 maps override the lightgrid_cellsize with a worldspawn key
 	if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{')
@@ -4134,6 +4162,9 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 			strlcpy(value, com_token, sizeof(value));
 			if (!strcmp("gridsize", key))
 			{
+#if _MSC_VER >= 1400
+#define sscanf sscanf_s
+#endif
 				if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
 					VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
 			}
@@ -4145,7 +4176,7 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 {
 	q3dtexture_t *in;
 	texture_t *out;
-	int i, count, c;
+	int i, count;
 
 	in = (q3dtexture_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
@@ -4167,12 +4198,8 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 	if (cls.state == ca_dedicated)
 		return;
 
-	c = 0;
 	for (i = 0;i < count;i++, in++, out++)
-		if (!Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false))
-			c++;
-	if (c)
-		Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
+		Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
 }
 
 static void Mod_Q3BSP_LoadPlanes(lump_t *l)
@@ -4228,6 +4255,34 @@ static void Mod_Q3BSP_LoadBrushSides(lump_t *l)
 	}
 }
 
+static void Mod_Q3BSP_LoadBrushSides_IG(lump_t *l)
+{
+	q3dbrushside_ig_t *in;
+	q3mbrushside_t *out;
+	int i, n, count;
+
+	in = (q3dbrushside_ig_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 = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+
+	loadmodel->brush.data_brushsides = out;
+	loadmodel->brush.num_brushsides = count;
+
+	for (i = 0;i < count;i++, in++, out++)
+	{
+		n = LittleLong(in->planeindex);
+		if (n < 0 || 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, loadmodel->num_textures);
+		out->texture = loadmodel->data_textures + n;
+	}
+}
+
 static void Mod_Q3BSP_LoadBrushes(lump_t *l)
 {
 	q3dbrush_t *in;
@@ -4277,6 +4332,9 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l)
 		}
 		// make the colbrush from the planes
 		out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
+
+		// this whole loop can take a while (e.g. on redstarrepublic4)
+		CL_KeepaliveMessage(false);
 	}
 	if (planes)
 		Mem_Free(planes);
@@ -4374,19 +4432,85 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 
 static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 {
-	q3dlightmap_t *in;
+	q3dlightmap_t *input_pointer;
 	int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
 	unsigned char *c;
-	unsigned char convertedpixels[128*128*4];
 
-	if (!l->filelen)
-		return;
+	unsigned char *convertedpixels;
+	char mapname[MAX_QPATH];
+	int size, bytesperpixel, rgbmap[3];
+	qboolean external;
+	unsigned char *inpixels[10000]; // max count q3map2 can output (it uses 4 digits)
+
+	// defaults for q3bsp
+	size = 128;
+	bytesperpixel = 3;
+	rgbmap[0] = 2;
+	rgbmap[1] = 1;
+	rgbmap[2] = 0;
+	external = false;
+	loadmodel->brushq3.lightmapsize = 128;
+
 	if (cls.state == ca_dedicated)
 		return;
-	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);
+
+	if(mod_q3bsp_nolightmaps.integer)
+	{
+		return;
+	}
+	else if(l->filelen)
+	{
+		// prefer internal LMs for compatibility (a BSP contains no info on whether external LMs exist)
+		if (developer_loading.integer)
+			Con_Printf("Using internal lightmaps\n");
+		input_pointer = (q3dlightmap_t *)(mod_base + l->fileofs);
+		if (l->filelen % sizeof(*input_pointer))
+			Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
+		count = l->filelen / sizeof(*input_pointer);
+		for(i = 0; i < count; ++i)
+			inpixels[i] = input_pointer[i].rgb;
+	}
+	else
+	{
+		// no internal lightmaps
+		// try external lightmaps
+		if (developer_loading.integer)
+			Con_Printf("Using external lightmaps\n");
+		FS_StripExtension(loadmodel->name, mapname, sizeof(mapname));
+		inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false);
+		if(!inpixels[0])
+			return;
+
+		// using EXTERNAL lightmaps instead
+		if(image_width != (int) CeilPowerOf2(image_width) || image_width != image_height)
+		{
+			Mem_Free(inpixels[0]);
+			Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name);
+		}
+
+		size = image_width;
+		bytesperpixel = 4;
+		rgbmap[0] = 0;
+		rgbmap[1] = 1;
+		rgbmap[2] = 2;
+		external = true;
+
+		for(count = 1; ; ++count)
+		{
+			inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false);
+			if(!inpixels[count])
+				break; // we got all of them
+			if(image_width != size || image_height != size)
+			{
+				for(i = 0; i <= count; ++i)
+					Mem_Free(inpixels[i]);
+				Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name);
+			}
+		}
+	}
+
+	convertedpixels = (unsigned char *) Mem_Alloc(tempmempool, size*size*4);
+	loadmodel->brushq3.lightmapsize = size;
 	loadmodel->brushq3.num_originallightmaps = count;
 
 	// now check the surfaces to see if any of them index an odd numbered
@@ -4429,11 +4553,17 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 	// blank lightmaps, which must be handled properly as well
 	if (endlightmap == 1 && count > 1)
 	{
-		c = in[1].rgb;
-		for (i = 0;i < 128*128*3;i++)
-			if (c[i])
+		c = inpixels[1];
+		for (i = 0;i < size*size;i++)
+		{
+			if (c[bytesperpixel*i + rgbmap[0]])
+				break;
+			if (c[bytesperpixel*i + rgbmap[1]])
+				break;
+			if (c[bytesperpixel*i + rgbmap[2]])
 				break;
-		if (i == 128*128*3)
+		}
+		if (i == size*size)
 		{
 			// all pixels in the unused lightmap were black...
 			loadmodel->brushq3.deluxemapping = false;
@@ -4446,6 +4576,14 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 	loadmodel->brushq3.num_lightmapmergepower = 0;
 	for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (128 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++)
 		loadmodel->brushq3.num_lightmapmergepower = power;
+
+	// as the lightmap size may actually be another power of 2, adjust for this
+	// (and interpret it as the power for 128x128 lightmaps above)
+	for(i = 0; (128 << i) < size; ++i)
+		loadmodel->brushq3.num_lightmapmergepower -= 1;
+	if(loadmodel->brushq3.num_lightmapmergepower < 0)
+		loadmodel->brushq3.num_lightmapmergepower = 0;
+
 	loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower;
 
 	loadmodel->brushq3.num_mergedlightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2);
@@ -4464,11 +4602,11 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 	{
 		// figure out which merged lightmap texture this fits into
 		int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2);
-		for (k = 0;k < 128*128;k++)
+		for (k = 0;k < size*size;k++)
 		{
-			convertedpixels[k*4+2] = in[i].rgb[k*3+0];
-			convertedpixels[k*4+1] = in[i].rgb[k*3+1];
-			convertedpixels[k*4+0] = in[i].rgb[k*3+2];
+			convertedpixels[k*4+0] = inpixels[i][k*bytesperpixel+rgbmap[0]];
+			convertedpixels[k*4+1] = inpixels[i][k*bytesperpixel+rgbmap[1]];
+			convertedpixels[k*4+2] = inpixels[i][k*bytesperpixel+rgbmap[2]];
 			convertedpixels[k*4+3] = 255;
 		}
 		if (loadmodel->brushq3.num_lightmapmergepower > 0)
@@ -4477,7 +4615,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 			if (!loadmodel->brushq3.data_lightmaps[lightmapindex])
 			{
 				// create a lightmap only as large as necessary to hold the
-				// remaining 128x128 blocks
+				// remaining size*size blocks
 				// if there are multiple merged lightmap textures then they will
 				// all be full size except the last one which may be smaller
 				// because it only needs to the remaining blocks, and it will often
@@ -4487,35 +4625,63 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 					;
 				for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2)
 					;
-				Con_DPrintf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*128, mergeheight*128, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
-				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+				if (developer_loading.integer)
+					Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
+				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
 				if (loadmodel->brushq3.data_deluxemaps)
-					loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+					loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
 			}
-			mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
-			mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
+			mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
+			mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
 			j = (i >> loadmodel->brushq3.deluxemapping) & ((1 << power2) - 1);
 			if (loadmodel->brushq3.deluxemapping && (i & 1))
-				R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+				R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size);
 			else
-				R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+				R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size);
 		}
 		else
 		{
 			// figure out which merged lightmap texture this fits into
 			if (loadmodel->brushq3.deluxemapping && (i & 1))
-				loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), 128, 128, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
 			else
-				loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), 128, 128, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
 		}
 	}
+
+	Mem_Free(convertedpixels);
+	if(external)
+	{
+		for(i = 0; i < count; ++i)
+			Mem_Free(inpixels[i]);
+	}
 }
 
+typedef struct patchtess_s
+{
+	patchinfo_t info;
+
+	// Auxiliary data used only by patch loading code in Mod_Q3BSP_LoadFaces
+	int surface_id;
+	float lodgroup[6];
+	float *originalvertex3f;
+} patchtess_t;
+
+#define PATCHTESS_SAME_LODGROUP(a,b) \
+	( \
+		(a).lodgroup[0] == (b).lodgroup[0] && \
+		(a).lodgroup[1] == (b).lodgroup[1] && \
+		(a).lodgroup[2] == (b).lodgroup[2] && \
+		(a).lodgroup[3] == (b).lodgroup[3] && \
+		(a).lodgroup[4] == (b).lodgroup[4] && \
+		(a).lodgroup[5] == (b).lodgroup[5] \
+	)
+
 static void Mod_Q3BSP_LoadFaces(lump_t *l)
 {
 	q3dface_t *in, *oldin;
 	msurface_t *out, *oldout;
-	int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles;
+	int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, cxtess, cytess;
 	float lightmaptcbase[2], lightmaptcscale[2];
 	//int *originalelement3i;
 	//int *originalneighbor3i;
@@ -4527,6 +4693,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	float *originaltexcoordtexture2f;
 	float *originaltexcoordlightmap2f;
 	float *v;
+	patchtess_t *patchtess = NULL;
+	int patchtesscount = 0;
+	qboolean again;
 
 	in = (q3dface_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
@@ -4537,6 +4706,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	loadmodel->data_surfaces = out;
 	loadmodel->num_surfaces = count;
 
+	if(count > 0)
+		patchtess = (patchtess_t*) Mem_Alloc(tempmempool, count * sizeof(*patchtess));
+
 	i = 0;
 	oldi = i;
 	oldin = in;
@@ -4547,7 +4719,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	{
 		// check face type first
 		type = LittleLong(in->type);
-		if (type != Q3FACETYPE_POLYGON
+		if (type != Q3FACETYPE_FLAT
 		 && type != Q3FACETYPE_PATCH
 		 && type != Q3FACETYPE_MESH
 		 && type != Q3FACETYPE_FLARE)
@@ -4584,7 +4756,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 				n = -1;
 			else if (n >= loadmodel->brushq3.num_originallightmaps)
 			{
-				Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps);
+				if(loadmodel->brushq3.num_originallightmaps != 0)
+					Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps);
 				n = -1;
 			}
 			else
@@ -4616,7 +4789,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		}
 		switch(type)
 		{
-		case Q3FACETYPE_POLYGON:
+		case Q3FACETYPE_FLAT:
 		case Q3FACETYPE_MESH:
 			// no processing necessary
 			break;
@@ -4629,6 +4802,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 				continue;
 			}
 			originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+
 			// convert patch to Q3FACETYPE_MESH
 			xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
 			ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
@@ -4636,20 +4810,37 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
 			ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
 			// bound to sanity settings
-			xtess = bound(1, xtess, 1024);
-			ytess = bound(1, ytess, 1024);
-			// bound to user limit on vertices
-			while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
-			{
-				if (xtess > ytess)
-					xtess--;
-				else
-					ytess--;
-			}
-			finalwidth = ((patchsize[0] - 1) * xtess) + 1;
-			finalheight = ((patchsize[1] - 1) * ytess) + 1;
-			numvertices = finalwidth * finalheight;
-			numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+			xtess = bound(0, xtess, 1024);
+			ytess = bound(0, ytess, 1024);
+
+			// lower quality collision patches! Same procedure as before, but different cvars
+			// convert patch to Q3FACETYPE_MESH
+			cxtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
+			cytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
+			// bound to user settings
+			cxtess = bound(r_subdivisions_collision_mintess.integer, cxtess, r_subdivisions_collision_maxtess.integer);
+			cytess = bound(r_subdivisions_collision_mintess.integer, cytess, r_subdivisions_collision_maxtess.integer);
+			// bound to sanity settings
+			cxtess = bound(0, cxtess, 1024);
+			cytess = bound(0, cytess, 1024);
+
+			// store it for the LOD grouping step
+	 		patchtess[patchtesscount].info.xsize = patchsize[0];
+	 		patchtess[patchtesscount].info.ysize = patchsize[1];
+	 		patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].xtess = xtess;
+	 		patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].ytess = ytess;
+	 		patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].xtess = cxtess;
+	 		patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess;
+	
+			patchtess[patchtesscount].surface_id = i;
+			patchtess[patchtesscount].lodgroup[0] = in->specific.patch.mins[0];
+			patchtess[patchtesscount].lodgroup[1] = in->specific.patch.mins[1];
+			patchtess[patchtesscount].lodgroup[2] = in->specific.patch.mins[2];
+			patchtess[patchtesscount].lodgroup[3] = in->specific.patch.maxs[0];
+			patchtess[patchtesscount].lodgroup[4] = in->specific.patch.maxs[1];
+			patchtess[patchtesscount].lodgroup[5] = in->specific.patch.maxs[2];
+			patchtess[patchtesscount].originalvertex3f = originalvertex3f;
+			++patchtesscount;
 			break;
 		case Q3FACETYPE_FLARE:
 			if (developer.integer >= 100)
@@ -4663,6 +4854,38 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		meshtriangles += out->num_triangles;
 	}
 
+	// Fix patches tesselations so that they make no seams
+	do
+	{
+		again = false;
+		for(i = 0; i < patchtesscount; ++i)
+		{
+			for(j = i+1; j < patchtesscount; ++j)
+			{
+				if (!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
+					continue;
+
+				if (Q3PatchAdjustTesselation(3, &patchtess[i].info, patchtess[i].originalvertex3f, &patchtess[j].info, patchtess[j].originalvertex3f) )
+					again = true;
+			}
+		}
+	}
+	while (again);
+
+	// Calculate resulting number of triangles
+	for(i = 0; i < patchtesscount; ++i)
+	{
+		finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess);
+		finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_VISUAL].ytess);
+		numvertices = finalwidth * finalheight;
+		numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+
+		oldout[patchtess[i].surface_id].num_vertices = numvertices;
+		oldout[patchtess[i].surface_id].num_triangles = numtriangles;
+		meshvertices += oldout[patchtess[i].surface_id].num_vertices;
+		meshtriangles += oldout[patchtess[i].surface_id].num_triangles;
+	}
+
 	i = oldi;
 	in = oldin;
 	out = oldout;
@@ -4681,7 +4904,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		out->num_firsttriangle = meshtriangles;
 		switch(type)
 		{
-		case Q3FACETYPE_POLYGON:
+		case Q3FACETYPE_FLAT:
 		case Q3FACETYPE_MESH:
 			// no processing necessary, except for lightmap merging
 			for (j = 0;j < out->num_vertices;j++)
@@ -4712,25 +4935,25 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
 			originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
 			originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
-			// convert patch to Q3FACETYPE_MESH
-			xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
-			ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
-			// bound to user settings
-			xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
-			ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
-			// bound to sanity settings
-			xtess = bound(1, xtess, 1024);
-			ytess = bound(1, ytess, 1024);
-			// bound to user limit on vertices
-			while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
+
+			xtess = ytess = cxtess = cytess = -1;
+			for(j = 0; j < patchtesscount; ++j)
+				if(patchtess[j].surface_id == i)
+				{
+					xtess = patchtess[j].info.lods[PATCH_LOD_VISUAL].xtess;
+					ytess = patchtess[j].info.lods[PATCH_LOD_VISUAL].ytess;
+					cxtess = patchtess[j].info.lods[PATCH_LOD_COLLISION].xtess;
+					cytess = patchtess[j].info.lods[PATCH_LOD_COLLISION].ytess;
+					break;
+				}
+			if(xtess == -1)
 			{
-				if (xtess > ytess)
-					xtess--;
-				else
-					ytess--;
+				Con_Printf("ERROR: patch %d isn't preprocessed?!?\n", i);
+				xtess = ytess = cxtess = cytess = 0;
 			}
-			finalwidth = ((patchsize[0] - 1) * xtess) + 1;
-			finalheight = ((patchsize[1] - 1) * ytess) + 1;
+
+			finalwidth = Q3PatchDimForTess(patchsize[0],xtess); //((patchsize[0] - 1) * xtess) + 1;
+			finalheight = Q3PatchDimForTess(patchsize[1],ytess); //((patchsize[1] - 1) * ytess) + 1;
 			finalvertices = finalwidth * finalheight;
 			finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
 			type = Q3FACETYPE_MESH;
@@ -4742,7 +4965,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
 			Q3PatchTesselateFloat(4, sizeof(float[4]), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
 			Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex);
+
 			out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f);
+
 			if (developer.integer >= 100)
 			{
 				if (out->num_triangles < finaltriangles)
@@ -4752,24 +4977,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			}
 			// q3map does not put in collision brushes for curves... ugh
 			// build the lower quality collision geometry
-			xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
-			ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
-			// bound to user settings
-			xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
-			ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
-			// bound to sanity settings
-			xtess = bound(1, xtess, 1024);
-			ytess = bound(1, ytess, 1024);
-			// bound to user limit on vertices
-			while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
-			{
-				if (xtess > ytess)
-					xtess--;
-				else
-					ytess--;
-			}
-			finalwidth = ((patchsize[0] - 1) * xtess) + 1;
-			finalheight = ((patchsize[1] - 1) * ytess) + 1;
+			finalwidth = Q3PatchDimForTess(patchsize[0],cxtess); //((patchsize[0] - 1) * cxtess) + 1;
+			finalheight = Q3PatchDimForTess(patchsize[1],cytess); //((patchsize[1] - 1) * cytess) + 1;
 			finalvertices = finalwidth * finalheight;
 			finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
 
@@ -4777,7 +4986,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			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);
+			Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess);
 			Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0);
 
 			//Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25);
@@ -4817,8 +5026,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			{
 				// figure out which part of the merged lightmap this fits into
 				int lightmapindex = LittleLong(in->lightmapindex) >> loadmodel->brushq3.deluxemapping;
-				int mergewidth = R_TextureWidth(out->lightmaptexture) / 128;
-				int mergeheight = R_TextureHeight(out->lightmaptexture) / 128;
+				int mergewidth = R_TextureWidth(out->lightmaptexture) / loadmodel->brushq3.lightmapsize;
+				int mergeheight = R_TextureHeight(out->lightmaptexture) / loadmodel->brushq3.lightmapsize;
 				lightmapindex &= mergewidth * mergeheight - 1;
 				lightmaptcscale[0] = 1.0f / mergewidth;
 				lightmaptcscale[1] = 1.0f / mergeheight;
@@ -4856,9 +5065,26 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		//out->lightmapinfo->styles[3] = 255;
 	}
 
+	i = oldi;
+	out = oldout;
+	for (;i < count;i++, out++)
+	{
+		if(out->num_vertices && out->num_triangles)
+			continue;
+		if(out->num_vertices == 0)
+			Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no vertices, ignoring\n", i);
+		if(out->num_triangles == 0)
+			Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no triangles, ignoring\n", i);
+	}
+
 	// for per pixel lighting
 	Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
 
+	// generate ushort elements array if possible
+	if (loadmodel->surfmesh.data_element3s)
+		for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+			loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+
 	// free the no longer needed vertex data
 	loadmodel->brushq3.num_vertices = 0;
 	if (loadmodel->brushq3.data_vertex3f)
@@ -4873,6 +5099,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	if (loadmodel->brushq3.data_element3i)
 		Mem_Free(loadmodel->brushq3.data_element3i);
 	loadmodel->brushq3.data_element3i = NULL;
+
+	if(patchtess)
+		Mem_Free(patchtess);
 }
 
 static void Mod_Q3BSP_LoadModels(lump_t *l)
@@ -5131,7 +5360,7 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l)
 	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)
+static void Mod_Q3BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
 {
 	int i, j, k, index[3];
 	float transformed[3], blend1, blend2, blend, stylescale;
@@ -5196,7 +5425,7 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc
 	//Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]);
 }
 
-static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe)
+static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe)
 {
 	int i;
 	mleaf_t *leaf;
@@ -5218,7 +5447,7 @@ static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model
 	// can't do point traces on curves (they have no thickness)
 }
 
-static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
 {
 	int i, startside, endside;
 	float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
@@ -5305,7 +5534,7 @@ 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)
+static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_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;
@@ -5386,7 +5615,7 @@ 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 start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q3BSP_TraceBox(dp_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];
@@ -5498,7 +5727,7 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const
 	return supercontents;
 }
 
-static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
+static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents)
 {
 	int supercontents = 0;
 	if (nativecontents & CONTENTSQ3_SOLID)
@@ -5524,7 +5753,7 @@ static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativec
 	return supercontents;
 }
 
-static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
+static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents)
 {
 	int nativecontents = 0;
 	if (supercontents & SUPERCONTENTS_SOLID)
@@ -5563,9 +5792,9 @@ void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
 		loadmodel->brush.num_leafs = numleafs;
 }
 
-void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
-	int i, j, numshadowmeshtriangles;
+	int i, j, numshadowmeshtriangles, lumps;
 	q3dheader_t *header;
 	float corner[3], yawradius, modelradius;
 	msurface_t *surface;
@@ -5577,13 +5806,12 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->numskins = 1;
 
 	header = (q3dheader_t *)buffer;
+	if((char *) bufferend < (char *) buffer + sizeof(q3dheader_t))
+		Host_Error("Mod_Q3BSP_Load: %s is smaller than its header", mod->name);
 
 	i = LittleLong(header->version);
-	if (i != Q3BSPVERSION)
+	if (i != Q3BSPVERSION && i != Q3BSPVERSION_IG && i != Q3BSPVERSION_LIVE)
 		Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
-	mod->brush.ishlbsp = false;
-	if (loadmodel->isworldmodel)
-		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
 
 	mod->soundfromcenter = true;
 	mod->TraceBox = Mod_Q3BSP_TraceBox;
@@ -5599,6 +5827,8 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
 	mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
 	mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+	mod->brush.AmbientSoundLevelsForPoint = NULL;
+	mod->brush.RoundUpToHullSize = NULL;
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
 	mod->Draw = R_Q1BSP_Draw;
 	mod->DrawDepth = R_Q1BSP_DrawDepth;
@@ -5607,22 +5837,38 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
 	mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
 	mod->DrawLight = R_Q1BSP_DrawLight;
-	mod->DrawAddWaterPlanes = NULL;
 
 	mod_base = (unsigned char *)header;
 
 	// swap all the lumps
 	header->ident = LittleLong(header->ident);
 	header->version = LittleLong(header->version);
-	for (i = 0;i < Q3HEADER_LUMPS;i++)
+	lumps = (header->version == Q3BSPVERSION_LIVE) ? Q3HEADER_LUMPS_LIVE : Q3HEADER_LUMPS;
+	for (i = 0;i < lumps;i++)
 	{
-		header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
-		header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+		j = (header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs));
+		if((char *) bufferend < (char *) buffer + j)
+			Host_Error("Mod_Q3BSP_Load: %s has a lump that starts outside the file!", mod->name);
+		j += (header->lumps[i].filelen = LittleLong(header->lumps[i].filelen));
+		if((char *) bufferend < (char *) buffer + j)
+			Host_Error("Mod_Q3BSP_Load: %s has a lump that ends outside the file!", mod->name);
+	}
+	/*
+	 * NO, do NOT clear them!
+	 * they contain actual data referenced by other stuff.
+	 * Instead, before using the advertisements lump, check header->versio
+	 * again!
+	 * Sorry, but otherwise it breaks memory of the first lump.
+	for (i = lumps;i < Q3HEADER_LUMPS_MAX;i++)
+	{
+		header->lumps[i].fileofs = 0;
+		header->lumps[i].filelen = 0;
 	}
+	*/
 
 	mod->brush.qw_md4sum = 0;
 	mod->brush.qw_md4sum2 = 0;
-	for (i = 0;i < Q3HEADER_LUMPS;i++)
+	for (i = 0;i < lumps;i++)
 	{
 		if (i == Q3LUMP_ENTITIES)
 			continue;
@@ -5630,12 +5876,18 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		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);
+
+		// all this checksumming can take a while, so let's send keepalives here too
+		CL_KeepaliveMessage(false);
 	}
 
 	Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
 	Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
 	Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]);
-	Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
+	if (header->version == Q3BSPVERSION_IG)
+		Mod_Q3BSP_LoadBrushSides_IG(&header->lumps[Q3LUMP_BRUSHSIDES]);
+	else
+		Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
 	Mod_Q3BSP_LoadBrushes(&header->lumps[Q3LUMP_BRUSHES]);
 	Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]);
 	Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]);
@@ -5659,17 +5911,20 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
 	// 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++)
+	if (cls.state != ca_dedicated)
 	{
-		surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
-		numshadowmeshtriangles += surface->num_triangles;
+		for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
+		{
+			surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
+			numshadowmeshtriangles += surface->num_triangles;
+		}
+		loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
+		for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
+			if (surface->num_triangles > 0)
+				Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
+		loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
+		Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
 	}
-	loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
-	for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
-		if (surface->num_triangles > 0)
-			Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
-	loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
-	Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
 
 	loadmodel->brush.num_leafs = 0;
 	Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
@@ -5680,16 +5935,14 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		if (i > 0)
 		{
 			char name[10];
-			// LordHavoc: only register submodels if it is the world
-			// (prevents external bsp models from replacing world submodels with
-			//  their own)
-			if (!loadmodel->isworldmodel)
-				continue;
 			// duplicate the basic information
-			sprintf(name, "*%i", i);
-			mod = Mod_FindName(name);
+			dpsnprintf(name, sizeof(name), "*%i", i);
+			mod = Mod_FindName(name, loadmodel->name);
+			// copy the base model to this one
 			*mod = *loadmodel;
+			// rename the clone back to its proper name
 			strlcpy(mod->name, name, sizeof(mod->name));
+			mod->brush.parentmodel = loadmodel;
 			// textures and memory belong to the main model
 			mod->texturepool = NULL;
 			mod->mempool = NULL;
@@ -5701,7 +5954,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->brush.BoxTouchingVisibleLeafs = NULL;
 			mod->brush.FindBoxClusters = NULL;
 			mod->brush.LightPoint = NULL;
-			mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+			mod->brush.AmbientSoundLevelsForPoint = NULL;
 		}
 		mod->brush.submodel = i;
 
@@ -5710,12 +5963,35 @@ 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 = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
-		for (j = 0;j < mod->nummodelsurfaces;j++)
-			mod->surfacelist[j] = mod->firstmodelsurface + j;
+		mod->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces));
+		Mod_MakeSortedSurfaces(mod);
 
 		VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
 		VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
+		// enlarge the bounding box to enclose all geometry of this model,
+		// because q3map2 sometimes lies (mostly to affect the lightgrid),
+		// which can in turn mess up the farclip (as well as culling when
+		// outside the level - an unimportant concern)
+
+		//printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
+		for (j = 0;j < mod->nummodelsurfaces;j++)
+		{
+			const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface;
+			const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex;
+			int k;
+			if (!surface->num_vertices)
+				continue;
+			for (k = 0;k < surface->num_vertices;k++, v += 3)
+			{
+				mod->normalmins[0] = min(mod->normalmins[0], v[0]);
+				mod->normalmins[1] = min(mod->normalmins[1], v[1]);
+				mod->normalmins[2] = min(mod->normalmins[2], v[2]);
+				mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]);
+				mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]);
+				mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]);
+			}
+		}
+		//printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
 		corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
 		corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
 		corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
@@ -5730,28 +6006,28 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		mod->radius = modelradius;
 		mod->radius2 = modelradius * modelradius;
 
+		// this gets altered below if sky or water is used
+		mod->DrawSky = NULL;
+		mod->DrawAddWaterPlanes = NULL;
+
 		for (j = 0;j < mod->nummodelsurfaces;j++)
 			if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_SKY)
 				break;
 		if (j < mod->nummodelsurfaces)
 			mod->DrawSky = R_Q1BSP_DrawSky;
-		else
-			mod->DrawSky = NULL;
 
 		for (j = 0;j < mod->nummodelsurfaces;j++)
 			if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
 				break;
 		if (j < mod->nummodelsurfaces)
 			mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
-		else
-			mod->DrawAddWaterPlanes = NULL;
 	}
 }
 
-void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
 	int i = LittleLong(((int *)buffer)[1]);
-	if (i == Q3BSPVERSION)
+	if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE)
 		Mod_Q3BSP_Load(mod,buffer, bufferend);
 	else if (i == Q2BSPVERSION)
 		Mod_Q2BSP_Load(mod,buffer, bufferend);
@@ -5759,12 +6035,12 @@ void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
 		Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
 }
 
-void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 {
 	Host_Error("Mod_MAP_Load: not yet implemented");
 }
 
-qboolean Mod_CanSeeBox_Trace(int numsamples, float t, model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
+qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
 {
 	// we already have done PVS culling at this point...
 	// so we don't need to do it again.