X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=dbf98b029a3e69ac1d86f05b9333176a4f62708d;hp=0b9653926a319628194e07127f2eee46fe7a0822;hb=6a8837801b8272f311dcb0c39e4b6b72b0a05a97;hpb=9d6bef38db35fdd649473cad2b698e3fcb898577

diff --git a/model_brush.c b/model_brush.c
index 0b965392..dbf98b02 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -28,10 +28,8 @@ 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 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_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"};
-cvar_t r_picmipworld = {0, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"};
+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)"};
@@ -56,9 +54,7 @@ void Mod_BrushInit(void)
 {
 //	Cvar_RegisterVariable(&r_subdivide_size);
 	Cvar_RegisterVariable(&halflifebsp);
-	Cvar_RegisterVariable(&mcbsp);
 	Cvar_RegisterVariable(&r_novis);
-	Cvar_RegisterVariable(&r_lightmaprgba);
 	Cvar_RegisterVariable(&r_picmipworld);
 	Cvar_RegisterVariable(&r_nosurftextures);
 	Cvar_RegisterVariable(&r_subdivisions_tolerance);
@@ -629,7 +625,7 @@ static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int nu
 	double t1, t2;
 
 	// variables that need to be stored on the stack when recursing
-	dclipnode_t *node;
+	mclipnode_t *node;
 	int side;
 	double midf, mid[3];
 
@@ -785,8 +781,16 @@ loc0:
 //#if COLLISIONPARANOID < 2
 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
 {
+	mplane_t *plane;
+	mclipnode_t *nodes = t->hull->clipnodes;
+	mplane_t *planes = t->hull->planes;
+	vec3_t point;
+	VectorCopy(t->start, point);
 	while (num >= 0)
-		num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist];
+	{
+		plane = planes + nodes[num].planenum;
+		num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+	}
 	num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
 	t->trace->startsupercontents |= num;
 	if (num & SUPERCONTENTS_LIQUIDSMASK)
@@ -822,13 +826,6 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 	VectorSubtract(boxmaxs, boxmins, boxsize);
 	if (boxsize[0] < 3)
 		rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
-	else if (model->brush.ismcbsp)
-	{
-		if (boxsize[2] < 48) // pick the nearest of 40 or 56
-			rhc.hull = &model->brushq1.hulls[2]; // 16x16x40
-		else
-			rhc.hull = &model->brushq1.hulls[1]; // 16x16x56
-	}
 	else if (model->brush.ishlbsp)
 	{
 		// LordHavoc: this has to have a minor tolerance (the .1) because of
@@ -886,6 +883,20 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 #endif
 }
 
+static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+	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;
+	while (num >= 0)
+	{
+		plane = planes + nodes[num].planenum;
+		num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+	}
+	return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
+}
+
 void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
 {
 #if 1
@@ -925,7 +936,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm
 #else
 	RecursiveHullCheckTraceInfo_t rhc;
 	static hull_t box_hull;
-	static dclipnode_t box_clipnodes[6];
+	static mclipnode_t box_clipnodes[6];
 	static mplane_t box_planes[6];
 	// fill in a default trace
 	memset(&rhc, 0, sizeof(rhc));
@@ -1111,8 +1122,14 @@ loc0:
 		// check for impact on this node
 		if (node->numsurfaces)
 		{
-			int i, ds, dt;
+			int i, dsi, dti, lmwidth, lmheight;
+			float ds, dt;
 			msurface_t *surface;
+			unsigned char *lightmap;
+			int maps, line3, size3;
+			float dsfrac;
+			float dtfrac;
+			float scale, w, w00, w01, w10, w11;
 
 			surface = model->data_surfaces + node->firstsurface;
 			for (i = 0;i < node->numsurfaces;i++, surface++)
@@ -1120,66 +1137,46 @@ loc0:
 				if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples)
 					continue;	// no lightmaps
 
-				ds = (int) (x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0];
-				dt = (int) (x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1];
+				// location we want to sample in the lightmap
+				ds = ((x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0]) * 0.0625f;
+				dt = ((x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1]) * 0.0625f;
+
+				// check the bounds
+				dsi = (int)ds;
+				dti = (int)dt;
+				lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1);
+				lmheight = ((surface->lightmapinfo->extents[1]>>4)+1);
 
-				if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1])
+				// is it in bounds?
+				if (dsi >= 0 && dsi < lmwidth-1 && dti >= 0 && dti < lmheight-1)
 				{
-					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);
+					// calculate bilinear interpolation factors
+					// and also multiply by fixedpoint conversion factors
+					dsfrac = ds - dsi;
+					dtfrac = dt - dti;
+					w00 = (1 - dsfrac) * (1 - dtfrac) * (1.0f / 32768.0f);
+					w01 = (    dsfrac) * (1 - dtfrac) * (1.0f / 32768.0f);
+					w10 = (1 - dsfrac) * (    dtfrac) * (1.0f / 32768.0f);
+					w11 = (    dsfrac) * (    dtfrac) * (1.0f / 32768.0f);
+
+					// values for pointer math
 					line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting
 					size3 = lmwidth * lmheight * 3; // LordHavoc: *3 for colored lighting
 
-					lightmap = surface->lightmapinfo->samples + ((dt>>4) * lmwidth + (ds>>4))*3; // LordHavoc: *3 for colored lighting
+					// look up the pixel
+					lightmap = surface->lightmapinfo->samples + dti * line3 + dsi*3; // LordHavoc: *3 for colored lighting
 
+					// bilinear filter each lightmap style, and sum them
 					for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;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;
-						r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale;
+						scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]];
+						w = w00 * scale;VectorMA(ambientcolor, w, lightmap            , ambientcolor);
+						w = w01 * scale;VectorMA(ambientcolor, w, lightmap + 3        , ambientcolor);
+						w = w10 * scale;VectorMA(ambientcolor, w, lightmap + line3    , ambientcolor);
+						w = w11 * scale;VectorMA(ambientcolor, w, lightmap + line3 + 3, ambientcolor);
 						lightmap += size3;
 					}
 
-/*
-LordHavoc: here's the readable version of the interpolation
-code, not quite as easy for the compiler to optimize...
-
-dsfrac is the X position in the lightmap pixel, * 16
-dtfrac is the Y position in the lightmap pixel, * 16
-r00 is top left corner, r01 is top right corner
-r10 is bottom left corner, r11 is bottom right corner
-g and b are the same layout.
-r0 and r1 are the top and bottom intermediate results
-
-first we interpolate the top two points, to get the top
-edge sample
-
-	r0 = (((r01-r00) * dsfrac) >> 4) + r00;
-	g0 = (((g01-g00) * dsfrac) >> 4) + g00;
-	b0 = (((b01-b00) * dsfrac) >> 4) + b00;
-
-then we interpolate the bottom two points, to get the
-bottom edge sample
-
-	r1 = (((r11-r10) * dsfrac) >> 4) + r10;
-	g1 = (((g11-g10) * dsfrac) >> 4) + g10;
-	b1 = (((b11-b10) * dsfrac) >> 4) + b10;
-
-then we interpolate the top and bottom samples to get the
-middle sample (the one which was requested)
-
-	r = (((r1-r0) * dtfrac) >> 4) + r0;
-	g = (((g1-g0) * dtfrac) >> 4) + g0;
-	b = (((b1-b0) * dtfrac) >> 4) + b0;
-*/
-
-					ambientcolor[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
-					ambientcolor[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
-					ambientcolor[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
 					return true; // success
 				}
 			}
@@ -1258,14 +1255,6 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp
 	if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
 		loadmodel->texturepool = R_AllocTexturePool();
 
-	// if sky isn't the right size, just use it as a solid layer
-	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;
-		return;
-	}
-
 	if (bytesperpixel == 4)
 	{
 		for (i = 0;i < 128;i++)
@@ -1287,34 +1276,35 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp
 			unsigned int i;
 			unsigned char b[4];
 		}
-		rgba;
+		bgra;
 		r = g = b = 0;
 		for (i = 0;i < 128;i++)
 		{
 			for (j = 0;j < 128;j++)
 			{
-				rgba.i = palette_complete[src[i*256 + j + 128]];
-				r += rgba.b[0];
-				g += rgba.b[1];
-				b += rgba.b[2];
+				p = src[i*256 + j + 128];
+				r += palette_rgb[p][0];
+				g += palette_rgb[p][1];
+				b += palette_rgb[p][2];
 			}
 		}
-		rgba.b[0] = r/(128*128);
-		rgba.b[1] = g/(128*128);
-		rgba.b[2] = b/(128*128);
-		rgba.b[3] = 0;
+		bgra.b[2] = r/(128*128);
+		bgra.b[1] = g/(128*128);
+		bgra.b[0] = b/(128*128);
+		bgra.b[3] = 0;
 		for (i = 0;i < 128;i++)
 		{
 			for (j = 0;j < 128;j++)
 			{
-				solidpixels[(i*128) + j] = palette_complete[src[i*256 + j + 128]];
-				alphapixels[(i*128) + j] = (p = src[i*256 + j]) ? palette_complete[p] : rgba.i;
+				solidpixels[(i*128) + j] = palette_bgra_complete[src[i*256 + j + 128]];
+				p = src[i*256 + j];
+				alphapixels[(i*128) + j] = p ? palette_bgra_complete[p] : bgra.i;
 			}
 		}
 	}
 
-	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);
+	loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_BGRA, TEXF_PRECACHE, NULL);
+	loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
 }
 
 static void Mod_Q1BSP_LoadTextures(lump_t *l)
@@ -1327,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;
 
@@ -1365,23 +1358,35 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			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;
 		}
 		tx->currentframe = tx;
+
+		// clear water settings
+		tx->reflectmin = 0;
+		tx->reflectmax = 1;
+		tx->refractfactor = 1;
+		Vector4Set(tx->refractcolor4f, 1, 1, 1, 1);
+		tx->reflectfactor = 1;
+		Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1);
+		tx->r_water_wateralpha = 1;
 	}
 
 	if (!m)
+	{
+		Con_Printf("%s: no miptex lump to load textures from\n", loadmodel->name);
 		return;
+	}
 
 	s = loadmodel->name;
 	if (!strncasecmp(s, "maps/", 5))
@@ -1394,15 +1399,28 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 	for (i = 0;i < m->nummiptex;i++)
 	{
 		dofs[i] = LittleLong(dofs[i]);
-		if (dofs[i] == -1 || r_nosurftextures.integer)
+		if (r_nosurftextures.integer)
 			continue;
+		if (dofs[i] == -1)
+		{
+			Con_DPrintf("%s: miptex #%i missing\n", loadmodel->name, i);
+			continue;
+		}
 		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++)
+		// 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++)
 			name[j] = dmiptex->name[j];
 		name[j] = 0;
 
+		if (!name[0])
+		{
+			sprintf(name, "unnamed%i", i);
+			Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name);
+		}
+
 		mtwidth = LittleLong(dmiptex->width);
 		mtheight = LittleLong(dmiptex->height);
 		mtdata = NULL;
@@ -1412,31 +1430,28 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			// texture included
 			if (j < 40 || j + mtwidth * mtheight > l->filelen)
 			{
-				Con_Printf("Texture \"%s\" in \"%s\"is corrupt or incomplete\n", dmiptex->name, loadmodel->name);
+				Con_Printf("%s: Texture \"%s\" is corrupt or incomplete\n", loadmodel->name, dmiptex->name);
 				continue;
 			}
 			mtdata = (unsigned char *)dmiptex + j;
 		}
 
 		if ((mtwidth & 15) || (mtheight & 15))
-			Con_Printf("warning: texture \"%s\" in \"%s\" is not 16 aligned\n", dmiptex->name, loadmodel->name);
+			Con_DPrintf("%s: warning: texture \"%s\" is not 16 aligned\n", loadmodel->name, dmiptex->name);
 
 		// LordHavoc: force all names to lowercase
 		for (j = 0;name[j];j++)
 			if (name[j] >= 'A' && name[j] <= 'Z')
 				name[j] += 'a' - 'A';
 
+		if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0))
+			continue;
+
 		tx = loadmodel->data_textures + i;
 		strlcpy(tx->name, name, sizeof(tx->name));
 		tx->width = mtwidth;
 		tx->height = mtheight;
 
-		if (!tx->name[0])
-		{
-			sprintf(tx->name, "unnamed%i", i);
-			Con_Printf("warning: unnamed texture in %s, renaming to %s\n", loadmodel->name, tx->name);
-		}
-
 		if (tx->name[0] == '*')
 		{
 			if (!strncmp(tx->name, "*lava", 5))
@@ -1473,8 +1488,8 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			{
 				if (loadmodel->isworldmodel)
 				{
-					data = loadimagepixels(tx->name, false, 0, 0);
-					if (data)
+					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);
@@ -1485,9 +1500,9 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			}
 			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), false);
+				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);
 				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), false);
+					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);
 				if (!skinframe)
 				{
 					// did not find external texture, load it from the bsp or wad3
@@ -1497,41 +1512,57 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 						unsigned char *pixels, *freepixels;
 						pixels = freepixels = NULL;
 						if (mtdata)
-							pixels = W_ConvertWAD3Texture(dmiptex);
+							pixels = W_ConvertWAD3TextureBGRA(dmiptex);
 						if (pixels == NULL)
-							pixels = freepixels = W_GetTexture(tx->name);
+							pixels = freepixels = W_GetTextureBGRA(tx->name);
 						if (pixels != NULL)
 						{
 							tx->width = image_width;
 							tx->height = image_height;
-							skinframe = R_SkinFrame_LoadInternal(tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, false, pixels, image_width, image_height, 32, NULL, NULL);
+							skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA | 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_LoadInternal(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL);
+						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);
 				}
 				// 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;
-				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;
+			else if (tx->skinframes[0] && tx->skinframes[0]->fog)
 				tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
 
 			// start out with no animation
@@ -1655,11 +1686,6 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l)
 		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 = (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)
 	{
 		// LordHavoc: hope is not lost yet, check for a .lit file to load
@@ -1676,7 +1702,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);
@@ -1688,7 +1715,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;
@@ -1748,13 +1776,13 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 	int i, j, k;
 	if (!data)
 		return;
-	if (!COM_ParseTokenConsole(&data))
+	if (!COM_ParseToken_Simple(&data, false, false))
 		return; // error
 	if (com_token[0] != '{')
 		return; // error
 	while (1)
 	{
-		if (!COM_ParseTokenConsole(&data))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			return; // error
 		if (com_token[0] == '}')
 			break; // end of worldspawn
@@ -1764,7 +1792,7 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 			strlcpy(key, com_token, sizeof(key));
 		while (key[strlen(key)-1] == ' ') // remove trailing spaces
 			key[strlen(key)-1] = 0;
-		if (!COM_ParseTokenConsole(&data))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			return; // error
 		dpsnprintf(value, sizeof(value), "%s", com_token);
 		if (!strcmp("wad", key)) // for HalfLife maps
@@ -1959,7 +1987,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
@@ -2123,46 +2151,78 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface)
 }
 #endif
 
-static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
+/* Maximum size of a single LM */
+#define MAX_SINGLE_LM_SIZE    256
+
+struct alloc_lm_row
+{
+	int rowY;
+	int currentX;
+};
+
+struct alloc_lm_state
 {
-	int y, x2, y2;
-	int bestx = totalwidth, besty = 0;
-	// find the left-most space we can find
-	for (y = 0;y <= totalheight - blockheight;y++)
-	{
-		x2 = 0;
-		for (y2 = 0;y2 < blockheight;y2++)
-			x2 = max(x2, lineused[y+y2]);
-		if (bestx > x2)
-		{
-			bestx = x2;
-			besty = y;
-		}
-	}
-	// if the best was not good enough, return failure
-	if (bestx > totalwidth - blockwidth)
-		return false;
-	// we found a good spot
-	if (outx)
-		*outx = bestx;
-	if (outy)
-		*outy = besty;
-	// now mark the space used
-	for (y2 = 0;y2 < blockheight;y2++)
-		lineused[besty+y2] = bestx + blockwidth;
-	// return success
+	int currentY;
+	struct alloc_lm_row rows[MAX_SINGLE_LM_SIZE];
+};
+
+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++)
+	{
+	  state->rows[r].currentX = 0;
+	  state->rows[r].rowY = -1;
+	}
+}
+
+static qboolean Mod_Q1BSP_AllocLightmapBlock(struct alloc_lm_state* state, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
+{
+	struct alloc_lm_row* row;
+	int r;
+
+	row = &(state->rows[blockheight]);
+	if ((row->rowY < 0) || (row->currentX + blockwidth > totalwidth))
+	{
+		if (state->currentY + blockheight <= totalheight)
+		{
+			row->rowY = state->currentY;
+			row->currentX = 0;
+			state->currentY += blockheight;
+		}
+		else
+		{
+			/* See if we can stuff the block into a higher row */
+			row = NULL;
+			for (r = blockheight; r < MAX_SINGLE_LM_SIZE; r++)
+			{
+				if ((state->rows[r].rowY >= 0)
+				  && (state->rows[r].currentX + blockwidth <= totalwidth))
+				{
+					row = &(state->rows[r]);
+					break;
+				}
+			}
+			if (row == NULL) return false;
+		}
+	}
+	*outy = row->rowY;
+	*outx = row->currentX;
+	row->currentX += blockwidth;
+
 	return true;
 }
 
+extern cvar_t gl_max_size;
 static void Mod_Q1BSP_LoadFaces(lump_t *l)
 {
 	dface_t *in;
 	msurface_t *surface;
-	int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber;
-	float texmins[2], texmaxs[2], val, lightmaptexcoordscale;
-#define LIGHTMAPSIZE 256
+	int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples;
+	float texmins[2], texmaxs[2], val;
 	rtexture_t *lightmaptexture, *deluxemaptexture;
-	int lightmap_lineused[LIGHTMAPSIZE];
 
 	in = (dface_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
@@ -2177,7 +2237,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	totaltris = 0;
 	for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
 	{
-		numedges = LittleShort(in->numedges);
+		numedges = (unsigned short)LittleShort(in->numedges);
 		totalverts += numedges;
 		totaltris += numedges - 2;
 	}
@@ -2187,7 +2247,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	lightmaptexture = NULL;
 	deluxemaptexture = r_texture_blanknormalmap;
 	lightmapnumber = 1;
-	lightmaptexcoordscale = 1.0f / (float)LIGHTMAPSIZE;
+	lightmapsize = max(256, gl_max_size.integer);
+	totallightmapsamples = 0;
 
 	totalverts = 0;
 	totaltris = 0;
@@ -2197,16 +2258,16 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
 		// FIXME: validate edges, texinfo, etc?
 		firstedge = LittleLong(in->firstedge);
-		numedges = LittleShort(in->numedges);
+		numedges = (unsigned short)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)", firstedge, numedges, loadmodel->brushq1.numsurfedges);
-		i = LittleShort(in->texinfo);
+		i = (unsigned short)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)", i, loadmodel->brushq1.numtexinfo);
 		surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i;
 		surface->texture = surface->lightmapinfo->texinfo->texture;
 
-		planenum = LittleShort(in->planenum);
+		planenum = (unsigned short)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)", planenum, loadmodel->brush.num_planes);
 
@@ -2285,7 +2346,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;
@@ -2304,42 +2365,73 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 		// check if we should apply a lightmap to this
 		if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples)
 		{
-			int i, iu, iv, lightmapx, lightmapy;
-			float u, v, ubase, vbase, uscale, vscale;
-
 			if (ssize > 256 || tsize > 256)
 				Host_Error("Bad surface extents");
+
+			if (lightmapsize < ssize)
+				lightmapsize = ssize;
+			if (lightmapsize < tsize)
+				lightmapsize = tsize;
+
+			totallightmapsamples += ssize*tsize;
+
 			// force lightmap upload on first time seeing the surface
+			//
+			// 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;
-			// 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);
+		}
+	}
+
+	// small maps (such as ammo boxes especially) don't need big lightmap
+	// textures, so this code tries to guess a good size based on
+	// totallightmapsamples (size of the lightmaps lump basically), as well as
+	// trying to max out the gl_max_size if there is a lot of lightmap data to
+	// store
+	// additionally, never choose a lightmapsize that is smaller than the
+	// largest surface encountered (as it would fail)
+	i = lightmapsize;
+	for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2)
+		;
 
-			// find a place for this lightmap
-			if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy))
+	// now that we've decided the lightmap texture size, we can do the rest
+	if (cls.state != ca_dedicated)
+	{
+		struct alloc_lm_state allocState;
+
+		for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
+		{
+			int i, iu, iv, lightmapx, lightmapy;
+			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;
+
+			if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
 			{
 				// allocate a texture pool if we need it
-				if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
+				if (loadmodel->texturepool == NULL)
 					loadmodel->texturepool = R_AllocTexturePool();
 				// could not find room, make a new lightmap
-				lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+				lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
 				if (loadmodel->brushq1.nmaplightdata)
-					deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+					deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
 				lightmapnumber++;
-				memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
-				Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy);
+				init_alloc_lm_state (&allocState);
+				Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
 			}
-
 			surface->lightmaptexture = lightmaptexture;
 			surface->deluxemaptexture = deluxemaptexture;
 			surface->lightmapinfo->lightmaporigin[0] = lightmapx;
 			surface->lightmapinfo->lightmaporigin[1] = lightmapy;
 
-			ubase = lightmapx * lightmaptexcoordscale;
-			vbase = lightmapy * lightmaptexcoordscale;
-			uscale = lightmaptexcoordscale;
-			vscale = lightmaptexcoordscale;
+			uscale = 1.0f / (float)lightmapsize;
+			vscale = 1.0f / (float)lightmapsize;
+			ubase = lightmapx * uscale;
+			vbase = lightmapy * vscale;
 
 			for (i = 0;i < surface->num_vertices;i++)
 			{
@@ -2352,8 +2444,38 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 				iv = (int) v;
 				(loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
 			}
+
+		}
+
+		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)
@@ -2419,16 +2541,40 @@ static void Mod_Q1BSP_LoadNodes(lump_t *l)
 		p = LittleLong(in->planenum);
 		out->plane = loadmodel->brush.data_planes + p;
 
-		out->firstsurface = LittleShort(in->firstface);
-		out->numsurfaces = LittleShort(in->numfaces);
+		out->firstsurface = (unsigned short)LittleShort(in->firstface);
+		out->numsurfaces = (unsigned short)LittleShort(in->numfaces);
 
 		for (j=0 ; j<2 ; j++)
 		{
-			p = LittleShort(in->children[j]);
-			if (p >= 0)
-				out->children[j] = loadmodel->brush.data_nodes + p;
+			// LordHavoc: this code supports broken bsp files produced by
+			// arguire qbsp which can produce more than 32768 nodes, any value
+			// below count is assumed to be a node number, any other value is
+			// assumed to be a leaf number
+			p = (unsigned short)LittleShort(in->children[j]);
+			if (p < count)
+			{
+				if (p < loadmodel->brush.num_nodes)
+					out->children[j] = loadmodel->brush.data_nodes + p;
+				else
+				{
+					Con_Printf("Mod_Q1BSP_LoadNodes: invalid node index %i (file has only %i nodes)\n", p, loadmodel->brush.num_nodes);
+					// map it to the solid leaf
+					out->children[j] = (mnode_t *)loadmodel->brush.data_leafs;
+				}
+			}
 			else
-				out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p));
+			{
+				// note this uses 65535 intentionally, -1 is leaf 0
+				p = 65535 - p;
+				if (p < loadmodel->brush.num_leafs)
+					out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + p);
+				else
+				{
+					Con_Printf("Mod_Q1BSP_LoadNodes: invalid leaf index %i (file has only %i leafs)\n", p, loadmodel->brush.num_leafs);
+					// map it to the solid leaf
+					out->children[j] = (mnode_t *)loadmodel->brush.data_leafs;
+				}
+			}
 		}
 	}
 
@@ -2467,9 +2613,9 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l)
 
 		out->contents = LittleLong(in->contents);
 
-		out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface);
-		out->numleafsurfaces = LittleShort(in->nummarksurfaces);
-		if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
+		out->firstleafsurface = loadmodel->brush.data_leafsurfaces + (unsigned short)LittleShort(in->firstmarksurface);
+		out->numleafsurfaces = (unsigned short)LittleShort(in->nummarksurfaces);
+		if (out->firstleafsurface < 0 || (unsigned short)LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
 		{
 			Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", (int)(out->firstleafsurface - loadmodel->brush.data_leafsurfaces), (int)(out->firstleafsurface + out->numleafsurfaces - loadmodel->brush.data_leafsurfaces), 0, loadmodel->brush.num_leafsurfaces);
 			out->firstleafsurface = NULL;
@@ -2502,11 +2648,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++)
@@ -2519,7 +2668,8 @@ qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void)
 
 static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 {
-	dclipnode_t *in, *out;
+	dclipnode_t *in;
+	mclipnode_t *out;
 	int			i, count;
 	hull_t		*hull;
 
@@ -2527,12 +2677,12 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 	if (l->filelen % sizeof(*in))
 		Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+	out = (mclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
 
 	loadmodel->brushq1.clipnodes = out;
 	loadmodel->brushq1.numclipnodes = count;
 
-	for (i = 1; i < hullinfo->numhulls; i++)
+	for (i = 1; i < MAX_MAP_HULLS; i++)
 	{
 		hull = &loadmodel->brushq1.hulls[i];
 		hull->clipnodes = out;
@@ -2551,12 +2701,15 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 	for (i=0 ; i<count ; i++, out++, in++)
 	{
 		out->planenum = LittleLong(in->planenum);
-		out->children[0] = LittleShort(in->children[0]);
-		out->children[1] = LittleShort(in->children[1]);
+		// LordHavoc: this code supports arguire qbsp's broken clipnodes indices (more than 32768 clipnodes), values above count are assumed to be contents values
+		out->children[0] = (unsigned short)LittleShort(in->children[0]);
+		out->children[1] = (unsigned short)LittleShort(in->children[1]);
+		if (out->children[0] >= count)
+			out->children[0] -= 65536;
+		if (out->children[1] >= count)
+			out->children[1] -= 65536;
 		if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes)
 			Host_Error("Corrupt clipping hull(out of range planenum)");
-		if (out->children[0] >= count || out->children[1] >= count)
-			Host_Error("Corrupt clipping hull(out of range child)");
 	}
 }
 
@@ -2564,14 +2717,14 @@ static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
 static void Mod_Q1BSP_MakeHull0(void)
 {
 	mnode_t		*in;
-	dclipnode_t *out;
+	mclipnode_t *out;
 	int			i;
 	hull_t		*hull;
 
 	hull = &loadmodel->brushq1.hulls[0];
 
 	in = loadmodel->brush.data_nodes;
-	out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
+	out = (mclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(*out));
 
 	hull->clipnodes = out;
 	hull->firstclipnode = 0;
@@ -2599,7 +2752,7 @@ static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
 
 	for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
 	{
-		j = (unsigned) LittleShort(in[i]);
+		j = (unsigned short) LittleShort(in[i]);
 		if (j >= loadmodel->num_surfaces)
 			Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
 		loadmodel->brush.data_leafsurfaces[i] = j;
@@ -2660,12 +2813,12 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 	if (!maptext)
 		return;
 	text = maptext;
-	if (!COM_ParseTokenConsole(&data))
+	if (!COM_ParseToken_Simple(&data, false, false))
 		return; // error
 	submodel = 0;
 	for (;;)
 	{
-		if (!COM_ParseTokenConsole(&data))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			break;
 		if (com_token[0] != '{')
 			return; // error
@@ -2676,7 +2829,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 		brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
 		for (;;)
 		{
-			if (!COM_ParseTokenConsole(&data))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				return; // error
 			if (com_token[0] == '}')
 				break; // end of entity
@@ -2700,7 +2853,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 				}
 				for (;;)
 				{
-					if (!COM_ParseTokenConsole(&data))
+					if (!COM_ParseToken_Simple(&data, false, false))
 						return; // error
 					if (com_token[0] == '}')
 						break; // end of brush
@@ -2709,25 +2862,25 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 					// FIXME: support hl .map format
 					for (pointnum = 0;pointnum < 3;pointnum++)
 					{
-						COM_ParseTokenConsole(&data);
+						COM_ParseToken_Simple(&data, false, false);
 						for (componentnum = 0;componentnum < 3;componentnum++)
 						{
-							COM_ParseTokenConsole(&data);
+							COM_ParseToken_Simple(&data, false, false);
 							point[pointnum][componentnum] = atof(com_token);
 						}
-						COM_ParseTokenConsole(&data);
+						COM_ParseToken_Simple(&data, false, false);
 					}
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					strlcpy(facetexture, com_token, sizeof(facetexture));
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					//scroll_s = atof(com_token);
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					//scroll_t = atof(com_token);
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					//rotate = atof(com_token);
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					//scale_s = atof(com_token);
-					COM_ParseTokenConsole(&data);
+					COM_ParseToken_Simple(&data, false, false);
 					//scale_t = atof(com_token);
 					TriangleNormal(point[0], point[1], point[2], planenormal);
 					VectorNormalizeDouble(planenormal);
@@ -3129,59 +3282,6 @@ static void Mod_Q1BSP_MakePortals(void)
 	Mod_Q1BSP_FinalizePortals();
 }
 
-static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *model)
-{
-	int i, j, stylecounts[256], totalcount, remapstyles[256];
-	msurface_t *surface;
-	memset(stylecounts, 0, sizeof(stylecounts));
-	for (i = 0;i < model->nummodelsurfaces;i++)
-	{
-		surface = model->data_surfaces + model->firstmodelsurface + i;
-		for (j = 0;j < MAXLIGHTMAPS;j++)
-			stylecounts[surface->lightmapinfo->styles[j]]++;
-	}
-	totalcount = 0;
-	model->brushq1.light_styles = 0;
-	for (i = 0;i < 255;i++)
-	{
-		if (stylecounts[i])
-		{
-			remapstyles[i] = model->brushq1.light_styles++;
-			totalcount += stylecounts[i] + 1;
-		}
-	}
-	if (!totalcount)
-		return;
-	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])
-			model->brushq1.light_style[model->brushq1.light_styles++] = i;
-	j = 0;
-	for (i = 0;i < model->brushq1.light_styles;i++)
-	{
-		model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
-		j += stylecounts[model->brushq1.light_style[i]] + 1;
-	}
-	for (i = 0;i < model->nummodelsurfaces;i++)
-	{
-		surface = model->data_surfaces + model->firstmodelsurface + i;
-		for (j = 0;j < MAXLIGHTMAPS;j++)
-			if (surface->lightmapinfo->styles[j] != 255)
-				*model->brushq1.light_styleupdatechains[remapstyles[surface->lightmapinfo->styles[j]]]++ = surface;
-	}
-	j = 0;
-	for (i = 0;i < model->brushq1.light_styles;i++)
-	{
-		*model->brushq1.light_styleupdatechains[i] = NULL;
-		model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
-		j += stylecounts[model->brushq1.light_style[i]] + 1;
-	}
-}
-
 //Returns PVS data for a given point
 //(note: can return NULL)
 static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
@@ -3224,7 +3324,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)
+static int Mod_Q1BSP_FatPVS(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);
@@ -3233,7 +3333,8 @@ static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsi
 		memset(pvsbuffer, 0xFF, bytes);
 		return bytes;
 	}
-	memset(pvsbuffer, 0, bytes);
+	if (!merge)
+		memset(pvsbuffer, 0, bytes);
 	Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes);
 	return bytes;
 }
@@ -3244,16 +3345,7 @@ static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, co
 	const hull_t *hull;
 
 	VectorSubtract(inmaxs, inmins, size);
-	if (cmodel->brush.ismcbsp)
-	{
-		if (size[0] < 3)
-			hull = &cmodel->brushq1.hulls[0]; // 0x0x0
-		else if (size[2] < 48) // pick the nearest of 40 or 56
-			hull = &cmodel->brushq1.hulls[2]; // 16x16x40
-		else
-			hull = &cmodel->brushq1.hulls[1]; // 16x16x56
-	}
-	else if (cmodel->brush.ishlbsp)
+	if (cmodel->brush.ishlbsp)
 	{
 		if (size[0] < 3)
 			hull = &cmodel->brushq1.hulls[0]; // 0x0x0
@@ -3289,96 +3381,57 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	float dist, modelyawradius, modelradius, *vec;
 	msurface_t *surface;
 	int numshadowmeshtriangles;
-	dheader_t _header;
 	hullinfo_t hullinfo;
+	int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256];
+	model_brush_lightstyleinfo_t styleinfo[256];
+	unsigned char *datapointer;
 
-	mod->type = mod_brushq1;
-
-	if (!memcmp (buffer, "MCBSPpad", 8))
-	{
-		unsigned char	*index;
-
-		mod->brush.ismcbsp = true;
-		mod->brush.ishlbsp = false;
+	mod->modeldatatypestring = "Q1BSP";
 
-		mod_base = (unsigned char*)buffer;
+	mod->type = mod_brushq1;
 
-		index = mod_base;
-		index += 8;
-		i = SB_ReadInt (&index);
-		if (i != MCBSPVERSION)
-			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
+	header = (dheader_t *)buffer;
 
-	// read hull info
-		hullinfo.numhulls = LittleLong(*(int*)index); index += 4;
-		hullinfo.filehulls = hullinfo.numhulls;
-		VectorClear (hullinfo.hullsizes[0][0]);
-		VectorClear (hullinfo.hullsizes[0][1]);
-		for (i = 1; i < hullinfo.numhulls; i++)
-		{
-			hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
-		}
+	i = LittleLong(header->version);
+	if (i != BSPVERSION && i != 30)
+		Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
+	mod->brush.ishlbsp = i == 30;
 
-	// read lumps
-		_header.version = 0;
-		for (i = 0; i < HEADER_LUMPS; i++)
-		{
-			_header.lumps[i].fileofs = SB_ReadInt (&index);
-			_header.lumps[i].filelen = SB_ReadInt (&index);
-		}
+// fill in hull info
+	VectorClear (hullinfo.hullsizes[0][0]);
+	VectorClear (hullinfo.hullsizes[0][1]);
+	if (mod->brush.ishlbsp)
+	{
+		mod->modeldatatypestring = "HLBSP";
 
-		header = &_header;
+		hullinfo.filehulls = 4;
+		VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
+		VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
+		VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
+		VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
+		VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
+		VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
 	}
 	else
 	{
-		header = (dheader_t *)buffer;
-
-		i = LittleLong(header->version);
-		if (i != BSPVERSION && i != 30)
-			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
-		mod->brush.ishlbsp = i == 30;
-		mod->brush.ismcbsp = false;
-
-	// fill in hull info
-		VectorClear (hullinfo.hullsizes[0][0]);
-		VectorClear (hullinfo.hullsizes[0][1]);
-		if (mod->brush.ishlbsp)
-		{
-			hullinfo.numhulls = 4;
-			hullinfo.filehulls = 4;
-			VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
-			VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
-			VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
-			VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
-			VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
-			VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
-		}
-		else
-		{
-			hullinfo.numhulls = 3;
-			hullinfo.filehulls = 4;
-			VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
-			VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
-			VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
-			VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
-		}
+		hullinfo.filehulls = 4;
+		VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
+		VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
+		VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
+		VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
+	}
 
-	// read lumps
-		mod_base = (unsigned char*)buffer;
-		for (i = 0; i < HEADER_LUMPS; i++)
-		{
-			header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
-			header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
-		}
+// read lumps
+	mod_base = (unsigned char*)buffer;
+	for (i = 0; i < HEADER_LUMPS; i++)
+	{
+		header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+		header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
 	}
 
 	mod->soundfromcenter = true;
 	mod->TraceBox = Mod_Q1BSP_TraceBox;
+	mod->PointSuperContents = Mod_Q1BSP_PointSuperContents;
 	mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
 	mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
 	mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
@@ -3395,16 +3448,10 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
 
 	if (loadmodel->isworldmodel)
-	{
 		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
-		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
-	}
 
 // load into heap
 
-	// 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++)
@@ -3466,14 +3513,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	if (loadmodel->brush.numsubmodels)
 		loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
 
-	if (loadmodel->isworldmodel)
-	{
-		// clear out any stale submodels or worldmodels lying around
-		// if we did this clear before now, an error might abort loading and
-		// leave things in a bad state
-		Mod_RemoveStaleWorldModels(loadmodel);
-	}
-
 	// LordHavoc: to clear the fog around the original quake submodel code, I
 	// will explain:
 	// first of all, some background info on the submodels:
@@ -3488,6 +3527,25 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	// LordHavoc: now the explanation of my sane way (which works identically):
 	// set up the world model, then on each submodel copy from the world model
 	// and set up the submodel with the respective model info.
+	totalstylesurfaces = 0;
+	totalstyles = 0;
+	for (i = 0;i < mod->brush.numsubmodels;i++)
+	{
+		memset(stylecounts, 0, sizeof(stylecounts));
+		for (k = 0;k < mod->brushq1.submodels[i].numfaces;k++)
+		{
+			surface = mod->data_surfaces + mod->brushq1.submodels[i].firstface + k;
+			for (j = 0;j < MAXLIGHTMAPS;j++)
+				stylecounts[surface->lightmapinfo->styles[j]]++;
+		}
+		for (k = 0;k < 255;k++)
+		{
+			totalstyles++;
+			if (stylecounts[k])
+				totalstylesurfaces += stylecounts[k];
+		}
+	}
+	datapointer = (unsigned char *)Mem_Alloc(mod->mempool, mod->num_surfaces * sizeof(int) + totalstyles * sizeof(model_brush_lightstyleinfo_t) + totalstylesurfaces * sizeof(int *));
 	for (i = 0;i < mod->brush.numsubmodels;i++)
 	{
 		// LordHavoc: this code was originally at the end of this loop, but
@@ -3531,13 +3589,16 @@ 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 *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+		mod->surfacelist = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
 		for (j = 0;j < mod->nummodelsurfaces;j++)
 			mod->surfacelist[j] = mod->firstmodelsurface + j;
 
-		// this gets altered below if sky is used
+		// 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;
@@ -3554,12 +3615,15 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->brush.LightPoint = NULL;
 			mod->brush.AmbientSoundLevelsForPoint = NULL;
 		}
-		Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod);
+		// copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius
+		VectorCopy(bm->mins, mod->normalmins);
+		VectorCopy(bm->maxs, mod->normalmaxs);
+		VectorCopy(bm->mins, mod->yawmins);
+		VectorCopy(bm->maxs, mod->yawmaxs);
+		VectorCopy(bm->mins, mod->rotatedmins);
+		VectorCopy(bm->maxs, mod->rotatedmaxs);
 		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++)
@@ -3567,15 +3631,11 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 				// 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;
+				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;
@@ -3586,13 +3646,56 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			}
 			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->yawmins[0] = min(mod->yawmins[0], -modelyawradius);
+			mod->yawmaxs[0] = min(mod->yawmaxs[0], -modelyawradius);
+			mod->yawmins[1] = min(mod->yawmins[1],  modelyawradius);
+			mod->yawmaxs[1] = min(mod->yawmaxs[1],  modelyawradius);
+			mod->rotatedmins[0] = min(mod->rotatedmins[0], -modelradius);
+			mod->rotatedmaxs[0] = min(mod->rotatedmaxs[0],  modelradius);
+			mod->rotatedmins[1] = min(mod->rotatedmins[1], -modelradius);
+			mod->rotatedmaxs[1] = min(mod->rotatedmaxs[1],  modelradius);
+			mod->rotatedmins[2] = min(mod->rotatedmins[2], -modelradius);
+			mod->rotatedmaxs[2] = min(mod->rotatedmaxs[2],  modelradius);
 			mod->radius = modelradius;
 			mod->radius2 = modelradius * modelradius;
+
+			// build lightstyle update chains
+			// (used to rapidly mark surface->cached_dlight on many surfaces
+			// when d_lightstylevalue changes)
+			memset(stylecounts, 0, sizeof(stylecounts));
+			for (k = 0;k < mod->nummodelsurfaces;k++)
+			{
+				surface = mod->data_surfaces + mod->firstmodelsurface + k;
+				for (j = 0;j < MAXLIGHTMAPS;j++)
+					stylecounts[surface->lightmapinfo->styles[j]]++;
+			}
+			mod->brushq1.num_lightstyles = 0;
+			for (k = 0;k < 255;k++)
+			{
+				if (stylecounts[k])
+				{
+					styleinfo[mod->brushq1.num_lightstyles].style = k;
+					styleinfo[mod->brushq1.num_lightstyles].value = 0;
+					styleinfo[mod->brushq1.num_lightstyles].numsurfaces = 0;
+					styleinfo[mod->brushq1.num_lightstyles].surfacelist = (int *)datapointer;datapointer += stylecounts[k] * sizeof(int);
+					remapstyles[k] = mod->brushq1.num_lightstyles;
+					mod->brushq1.num_lightstyles++;
+				}
+			}
+			for (k = 0;k < mod->nummodelsurfaces;k++)
+			{
+				surface = mod->data_surfaces + mod->firstmodelsurface + k;
+				for (j = 0;j < MAXLIGHTMAPS;j++)
+				{
+					if (surface->lightmapinfo->styles[j] != 255)
+					{
+						int r = remapstyles[surface->lightmapinfo->styles[j]];
+						styleinfo[r].surfacelist[styleinfo[r].numsurfaces++] = mod->firstmodelsurface + k;
+					}
+				}
+			}
+			mod->brushq1.data_lightstyleinfo = (model_brush_lightstyleinfo_t *)datapointer;datapointer += mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t);
+			memcpy(mod->brushq1.data_lightstyleinfo, styleinfo, mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t));
 		}
 		else
 		{
@@ -3995,6 +4098,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
 	Host_Error("Mod_Q2BSP_Load: not yet implemented");
 
+	mod->modeldatatypestring = "Q2BSP";
+
 	mod->type = mod_brushq2;
 
 	header = (q2dheader_t *)buffer;
@@ -4003,12 +4108,8 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	if (i != Q2BSPVERSION)
 		Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
 	mod->brush.ishlbsp = false;
-	mod->brush.ismcbsp = false;
 	if (loadmodel->isworldmodel)
-	{
 		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
-		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
-	}
 
 	mod_base = (unsigned char *)header;
 
@@ -4016,9 +4117,6 @@ void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	for (i = 0;i < (int) sizeof(*header) / 4;i++)
 		((int *)header)[i] = LittleLong(((int *)header)[i]);
 
-	// 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++)
@@ -4069,11 +4167,11 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 	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
-	if (data && COM_ParseTokenConsole(&data) && com_token[0] == '{')
+	if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{')
 	{
 		while (1)
 		{
-			if (!COM_ParseTokenConsole(&data))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				break; // error
 			if (com_token[0] == '}')
 				break; // end of worldspawn
@@ -4083,7 +4181,7 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 				strlcpy(key, com_token, sizeof(key));
 			while (key[strlen(key)-1] == ' ') // remove trailing spaces
 				key[strlen(key)-1] = 0;
-			if (!COM_ParseTokenConsole(&data))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				break; // error
 			strlcpy(value, com_token, sizeof(value));
 			if (!strcmp("gridsize", key))
@@ -4095,373 +4193,11 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l)
 	}
 }
 
-// FIXME: make MAXSHADERS dynamic
-#define Q3SHADER_MAXSHADERS 4096
-#define Q3SHADER_MAXLAYERS 8
-
-typedef struct q3shaderinfo_layer_s
-{
-	int alphatest;
-	int clampmap;
-	float framerate;
-	int numframes;
-	char texturename[TEXTURE_MAXFRAMES][Q3PATHLENGTH];
-	int blendfunc[2];
-	qboolean rgbgenvertex;
-	qboolean alphagenvertex;
-}
-q3shaderinfo_layer_t;
-
-typedef struct q3shaderinfo_s
-{
-	char name[Q3PATHLENGTH];
-	int surfaceparms;
-	int textureflags;
-	int numlayers;
-	qboolean lighting;
-	qboolean vertexalpha;
-	qboolean textureblendalpha;
-	q3shaderinfo_layer_t *primarylayer, *backgroundlayer;
-	q3shaderinfo_layer_t layers[Q3SHADER_MAXLAYERS];
-	char skyboxname[Q3PATHLENGTH];
-}
-q3shaderinfo_t;
-
-int q3shaders_numshaders;
-q3shaderinfo_t q3shaders_shaders[Q3SHADER_MAXSHADERS];
-
-static void Mod_Q3BSP_LoadShaders(void)
-{
-	int j;
-	int fileindex;
-	fssearch_t *search;
-	char *f;
-	const char *text;
-	q3shaderinfo_t *shader;
-	q3shaderinfo_layer_t *layer;
-	int numparameters;
-	char parameter[TEXTURE_MAXFRAMES + 4][Q3PATHLENGTH];
-	search = FS_Search("scripts/*.shader", true, false);
-	if (!search)
-		return;
-	q3shaders_numshaders = 0;
-	for (fileindex = 0;fileindex < search->numfilenames;fileindex++)
-	{
-		text = f = (char *)FS_LoadFile(search->filenames[fileindex], tempmempool, false, NULL);
-		if (!f)
-			continue;
-		while (COM_ParseToken(&text, false))
-		{
-			if (q3shaders_numshaders >= Q3SHADER_MAXSHADERS)
-			{
-				Con_Printf("Mod_Q3BSP_LoadShaders: too many shaders!\n");
-				break;
-			}
-			shader = q3shaders_shaders + q3shaders_numshaders++;
-			memset(shader, 0, sizeof(*shader));
-			strlcpy(shader->name, com_token, sizeof(shader->name));
-			if (!COM_ParseToken(&text, false) || strcasecmp(com_token, "{"))
-			{
-				Con_Printf("%s parsing error - expected \"{\", found \"%s\"\n", search->filenames[fileindex], com_token);
-				break;
-			}
-			while (COM_ParseToken(&text, false))
-			{
-				if (!strcasecmp(com_token, "}"))
-					break;
-				if (!strcasecmp(com_token, "{"))
-				{
-					if (shader->numlayers < Q3SHADER_MAXLAYERS)
-					{
-						layer = shader->layers + shader->numlayers++;
-						layer->rgbgenvertex = false;
-						layer->alphagenvertex = false;
-						layer->blendfunc[0] = GL_ONE;
-						layer->blendfunc[1] = GL_ZERO;
-					}
-					else
-						layer = NULL;
-					while (COM_ParseToken(&text, false))
-					{
-						if (!strcasecmp(com_token, "}"))
-							break;
-						if (!strcasecmp(com_token, "\n"))
-							continue;
-						if (layer == NULL)
-							continue;
-						numparameters = 0;
-						for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
-						{
-							if (j < TEXTURE_MAXFRAMES + 4)
-							{
-								strlcpy(parameter[j], com_token, sizeof(parameter[j]));
-								numparameters = j + 1;
-							}
-							if (!COM_ParseToken(&text, true))
-								break;
-						}
-						if (developer.integer >= 100)
-						{
-							Con_Printf("%s %i: ", shader->name, shader->numlayers - 1);
-							for (j = 0;j < numparameters;j++)
-								Con_Printf(" %s", parameter[j]);
-							Con_Print("\n");
-						}
-						if (numparameters >= 2 && !strcasecmp(parameter[0], "blendfunc"))
-						{
-							if (numparameters == 2)
-							{
-								if (!strcasecmp(parameter[1], "add"))
-								{
-									layer->blendfunc[0] = GL_ONE;
-									layer->blendfunc[1] = GL_ONE;
-								}
-								else if (!strcasecmp(parameter[1], "filter"))
-								{
-									layer->blendfunc[0] = GL_DST_COLOR;
-									layer->blendfunc[1] = GL_ZERO;
-								}
-								else if (!strcasecmp(parameter[1], "blend"))
-								{
-									layer->blendfunc[0] = GL_SRC_ALPHA;
-									layer->blendfunc[1] = GL_ONE_MINUS_SRC_ALPHA;
-								}
-							}
-							else if (numparameters == 3)
-							{
-								int k;
-								for (k = 0;k < 2;k++)
-								{
-									if (!strcasecmp(parameter[k+1], "GL_ONE"))
-										layer->blendfunc[k] = GL_ONE;
-									else if (!strcasecmp(parameter[k+1], "GL_ZERO"))
-										layer->blendfunc[k] = GL_ZERO;
-									else if (!strcasecmp(parameter[k+1], "GL_SRC_COLOR"))
-										layer->blendfunc[k] = GL_SRC_COLOR;
-									else if (!strcasecmp(parameter[k+1], "GL_SRC_ALPHA"))
-										layer->blendfunc[k] = GL_SRC_ALPHA;
-									else if (!strcasecmp(parameter[k+1], "GL_DST_COLOR"))
-										layer->blendfunc[k] = GL_DST_COLOR;
-									else if (!strcasecmp(parameter[k+1], "GL_DST_ALPHA"))
-										layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
-									else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_COLOR"))
-										layer->blendfunc[k] = GL_ONE_MINUS_SRC_COLOR;
-									else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_ALPHA"))
-										layer->blendfunc[k] = GL_ONE_MINUS_SRC_ALPHA;
-									else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_COLOR"))
-										layer->blendfunc[k] = GL_ONE_MINUS_DST_COLOR;
-									else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_ALPHA"))
-										layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
-									else
-										layer->blendfunc[k] = GL_ONE; // default in case of parsing error
-								}
-							}
-						}
-						if (numparameters >= 2 && !strcasecmp(parameter[0], "alphafunc"))
-							layer->alphatest = true;
-						if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap")))
-						{
-							if (!strcasecmp(parameter[0], "clampmap"))
-								layer->clampmap = true;
-							layer->numframes = 1;
-							layer->framerate = 1;
-							strlcpy(layer->texturename[0], parameter[1], sizeof(layer->texturename));
-							if (!strcasecmp(parameter[1], "$lightmap"))
-								shader->lighting = true;
-						}
-						else if (numparameters >= 3 && (!strcasecmp(parameter[0], "animmap") || !strcasecmp(parameter[0], "animclampmap")))
-						{
-							int i;
-							layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES);
-							layer->framerate = atof(parameter[1]);
-							for (i = 0;i < layer->numframes;i++)
-								strlcpy(layer->texturename[i], parameter[i + 2], sizeof(layer->texturename));
-						}
-						else if (numparameters >= 2 && !strcasecmp(parameter[0], "rgbgen") && !strcasecmp(parameter[1], "vertex"))
-							layer->rgbgenvertex = true;
-						else if (numparameters >= 2 && !strcasecmp(parameter[0], "alphagen") && !strcasecmp(parameter[1], "vertex"))
-							layer->alphagenvertex = true;
-						// break out a level if it was }
-						if (!strcasecmp(com_token, "}"))
-							break;
-					}
-					if (layer->rgbgenvertex)
-						shader->lighting = true;
-					if (layer->alphagenvertex)
-					{
-						if (layer == shader->layers + 0)
-						{
-							// vertex controlled transparency
-							shader->vertexalpha = true;
-						}
-						else
-						{
-							// multilayer terrain shader or similar
-							shader->textureblendalpha = true;
-						}
-					}
-					continue;
-				}
-				numparameters = 0;
-				for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
-				{
-					if (j < TEXTURE_MAXFRAMES + 4)
-					{
-						strlcpy(parameter[j], com_token, sizeof(parameter[j]));
-						numparameters = j + 1;
-					}
-					if (!COM_ParseToken(&text, true))
-						break;
-				}
-				if (fileindex == 0 && !strcasecmp(com_token, "}"))
-					break;
-				if (developer.integer >= 100)
-				{
-					Con_Printf("%s: ", shader->name);
-					for (j = 0;j < numparameters;j++)
-						Con_Printf(" %s", parameter[j]);
-					Con_Print("\n");
-				}
-				if (numparameters < 1)
-					continue;
-				if (!strcasecmp(parameter[0], "surfaceparm") && numparameters >= 2)
-				{
-					if (!strcasecmp(parameter[1], "alphashadow"))
-						shader->surfaceparms |= Q3SURFACEPARM_ALPHASHADOW;
-					else if (!strcasecmp(parameter[1], "areaportal"))
-						shader->surfaceparms |= Q3SURFACEPARM_AREAPORTAL;
-					else if (!strcasecmp(parameter[1], "botclip"))
-						shader->surfaceparms |= Q3SURFACEPARM_BOTCLIP;
-					else if (!strcasecmp(parameter[1], "clusterportal"))
-						shader->surfaceparms |= Q3SURFACEPARM_CLUSTERPORTAL;
-					else if (!strcasecmp(parameter[1], "detail"))
-						shader->surfaceparms |= Q3SURFACEPARM_DETAIL;
-					else if (!strcasecmp(parameter[1], "donotenter"))
-						shader->surfaceparms |= Q3SURFACEPARM_DONOTENTER;
-					else if (!strcasecmp(parameter[1], "dust"))
-						shader->surfaceparms |= Q3SURFACEPARM_DUST;
-					else if (!strcasecmp(parameter[1], "hint"))
-						shader->surfaceparms |= Q3SURFACEPARM_HINT;
-					else if (!strcasecmp(parameter[1], "fog"))
-						shader->surfaceparms |= Q3SURFACEPARM_FOG;
-					else if (!strcasecmp(parameter[1], "lava"))
-						shader->surfaceparms |= Q3SURFACEPARM_LAVA;
-					else if (!strcasecmp(parameter[1], "lightfilter"))
-						shader->surfaceparms |= Q3SURFACEPARM_LIGHTFILTER;
-					else if (!strcasecmp(parameter[1], "lightgrid"))
-						shader->surfaceparms |= Q3SURFACEPARM_LIGHTGRID;
-					else if (!strcasecmp(parameter[1], "metalsteps"))
-						shader->surfaceparms |= Q3SURFACEPARM_METALSTEPS;
-					else if (!strcasecmp(parameter[1], "nodamage"))
-						shader->surfaceparms |= Q3SURFACEPARM_NODAMAGE;
-					else if (!strcasecmp(parameter[1], "nodlight"))
-						shader->surfaceparms |= Q3SURFACEPARM_NODLIGHT;
-					else if (!strcasecmp(parameter[1], "nodraw"))
-						shader->surfaceparms |= Q3SURFACEPARM_NODRAW;
-					else if (!strcasecmp(parameter[1], "nodrop"))
-						shader->surfaceparms |= Q3SURFACEPARM_NODROP;
-					else if (!strcasecmp(parameter[1], "noimpact"))
-						shader->surfaceparms |= Q3SURFACEPARM_NOIMPACT;
-					else if (!strcasecmp(parameter[1], "nolightmap"))
-						shader->surfaceparms |= Q3SURFACEPARM_NOLIGHTMAP;
-					else if (!strcasecmp(parameter[1], "nomarks"))
-						shader->surfaceparms |= Q3SURFACEPARM_NOMARKS;
-					else if (!strcasecmp(parameter[1], "nomipmaps"))
-						shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
-					else if (!strcasecmp(parameter[1], "nonsolid"))
-						shader->surfaceparms |= Q3SURFACEPARM_NONSOLID;
-					else if (!strcasecmp(parameter[1], "origin"))
-						shader->surfaceparms |= Q3SURFACEPARM_ORIGIN;
-					else if (!strcasecmp(parameter[1], "playerclip"))
-						shader->surfaceparms |= Q3SURFACEPARM_PLAYERCLIP;
-					else if (!strcasecmp(parameter[1], "sky"))
-						shader->surfaceparms |= Q3SURFACEPARM_SKY;
-					else if (!strcasecmp(parameter[1], "slick"))
-						shader->surfaceparms |= Q3SURFACEPARM_SLICK;
-					else if (!strcasecmp(parameter[1], "slime"))
-						shader->surfaceparms |= Q3SURFACEPARM_SLIME;
-					else if (!strcasecmp(parameter[1], "structural"))
-						shader->surfaceparms |= Q3SURFACEPARM_STRUCTURAL;
-					else if (!strcasecmp(parameter[1], "trans"))
-						shader->surfaceparms |= Q3SURFACEPARM_TRANS;
-					else if (!strcasecmp(parameter[1], "water"))
-						shader->surfaceparms |= Q3SURFACEPARM_WATER;
-					else if (!strcasecmp(parameter[1], "pointlight"))
-						shader->surfaceparms |= Q3SURFACEPARM_POINTLIGHT;
-					else if (!strcasecmp(parameter[1], "antiportal"))
-						shader->surfaceparms |= Q3SURFACEPARM_ANTIPORTAL;
-					else
-						Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]);
-				}
-				else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
-				{
-					// some q3 skies don't have the sky parm set
-					shader->surfaceparms |= Q3SURFACEPARM_SKY;
-					strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname));
-				}
-				else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2)
-				{
-					// some q3 skies don't have the sky parm set
-					shader->surfaceparms |= Q3SURFACEPARM_SKY;
-					if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-"))
-						strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname));
-				}
-				else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2)
-				{
-					if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided"))
-						shader->textureflags |= Q3TEXTUREFLAG_TWOSIDED;
-				}
-				else if (!strcasecmp(parameter[0], "nomipmaps"))
-					shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
-				else if (!strcasecmp(parameter[0], "nopicmip"))
-					shader->textureflags |= Q3TEXTUREFLAG_NOPICMIP;
-				else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
-				{
-					if (!strcasecmp(parameter[1], "autosprite") && numparameters == 2)
-						shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE;
-					if (!strcasecmp(parameter[1], "autosprite2") && numparameters == 2)
-						shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE2;
-				}
-			}
-			// identify if this is a blended terrain shader or similar
-			if (shader->numlayers)
-			{
-				shader->backgroundlayer = NULL;
-				shader->primarylayer = shader->layers + 0;
-				if ((shader->layers[0].blendfunc[0] == GL_ONE       && shader->layers[0].blendfunc[1] == GL_ZERO                && !shader->layers[0].alphatest)
-				&& ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA && !shader->layers[0].alphatest)
-				||  (shader->layers[1].blendfunc[0] == GL_ONE       && shader->layers[1].blendfunc[1] == GL_ZERO                &&  shader->layers[1].alphatest)))
-				{
-					// terrain blending or other effects
-					shader->backgroundlayer = shader->layers + 0;
-					shader->primarylayer = shader->layers + 1;
-				}
-				// now see if the lightmap came first, and if so choose the second texture instead
-				if (!strcasecmp(shader->primarylayer->texturename[0], "$lightmap"))
-				{
-					shader->backgroundlayer = NULL;
-					shader->primarylayer = shader->layers + 1;
-				}
-			}
-		}
-		Mem_Free(f);
-	}
-}
-
-q3shaderinfo_t *Mod_Q3BSP_LookupShader(const char *name)
-{
-	int i;
-	for (i = 0;i < Q3SHADER_MAXSHADERS;i++)
-		if (!strcasecmp(q3shaders_shaders[i].name, name))
-			return q3shaders_shaders + i;
-	return NULL;
-}
-
 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))
@@ -4483,145 +4219,8 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 	if (cls.state == ca_dedicated)
 		return;
 
-	// parse the Q3 shader files
-	Mod_Q3BSP_LoadShaders();
-
-	c = 0;
 	for (i = 0;i < count;i++, in++, out++)
-	{
-		q3shaderinfo_t *shader;
-		shader = Mod_Q3BSP_LookupShader(out->name);
-		if (shader)
-		{
-			out->surfaceparms = shader->surfaceparms;
-			out->textureflags = shader->textureflags;
-			out->basematerialflags = 0;
-			if (shader->surfaceparms & Q3SURFACEPARM_SKY)
-			{
-				out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
-				if (shader->skyboxname[0])
-				{
-					// quake3 seems to append a _ to the skybox name, so this must do so as well
-					dpsnprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", shader->skyboxname);
-				}
-			}
-			else if ((out->surfaceflags & Q3SURFACEFLAG_NODRAW) || shader->numlayers == 0)
-				out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
-			else if (shader->surfaceparms & Q3SURFACEPARM_LAVA)
-				out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOSHADOW;
-			else if (shader->surfaceparms & Q3SURFACEPARM_SLIME)
-				out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
-			else if (shader->surfaceparms & Q3SURFACEPARM_WATER)
-				out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
-			else
-				out->basematerialflags |= MATERIALFLAG_WALL;
-			if (shader->layers[0].alphatest)
-				out->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW;
-			if (shader->textureflags & Q3TEXTUREFLAG_TWOSIDED)
-				out->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
-			if (shader->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
-				out->basematerialflags |= MATERIALFLAG_NOSHADOW;
-			out->customblendfunc[0] = GL_ONE;
-			out->customblendfunc[1] = GL_ZERO;
-			if (shader->numlayers > 0)
-			{
-				out->customblendfunc[0] = shader->layers[0].blendfunc[0];
-				out->customblendfunc[1] = shader->layers[0].blendfunc[1];
-/*
-Q3 shader blendfuncs actually used in the game (* = supported by DP)
-* additive               GL_ONE GL_ONE
-  additive weird         GL_ONE GL_SRC_ALPHA
-  additive weird 2       GL_ONE GL_ONE_MINUS_SRC_ALPHA
-* alpha                  GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA
-  alpha inverse          GL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA
-  brighten               GL_DST_COLOR GL_ONE
-  brighten               GL_ONE GL_SRC_COLOR
-  brighten weird         GL_DST_COLOR GL_ONE_MINUS_DST_ALPHA
-  brighten weird 2       GL_DST_COLOR GL_SRC_ALPHA
-* modulate               GL_DST_COLOR GL_ZERO
-* modulate               GL_ZERO GL_SRC_COLOR
-  modulate inverse       GL_ZERO GL_ONE_MINUS_SRC_COLOR
-  modulate inverse alpha GL_ZERO GL_SRC_ALPHA
-  modulate weird inverse GL_ONE_MINUS_DST_COLOR GL_ZERO
-* modulate x2            GL_DST_COLOR GL_SRC_COLOR
-* no blend               GL_ONE GL_ZERO
-  nothing                GL_ZERO GL_ONE
-*/
-				// if not opaque, figure out what blendfunc to use
-				if (shader->layers[0].blendfunc[0] != GL_ONE || shader->layers[0].blendfunc[1] != GL_ZERO)
-				{
-					if (shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ONE)
-						out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
-					else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE)
-						out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
-					else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA)
-						out->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
-					else
-						out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
-				}
-			}
-			if (!shader->lighting)
-				out->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
-			if (shader->primarylayer)
-			{
-				int j;
-				out->numskinframes = shader->primarylayer->numframes;
-				out->skinframerate = shader->primarylayer->framerate;
-				for (j = 0;j < shader->primarylayer->numframes;j++)
-					if (!(out->skinframes[j] = R_SkinFrame_LoadExternal(shader->primarylayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | ((!r_picmipworld.integer || (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP)) ? 0 : TEXF_PICMIP) | (shader->primarylayer->clampmap ? TEXF_CLAMP : 0), false)))
-						Con_DPrintf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->primarylayer->texturename[j], j, out->name);
-			}
-			if (shader->backgroundlayer)
-			{
-				int j;
-				out->backgroundnumskinframes = shader->backgroundlayer->numframes;
-				out->backgroundskinframerate = shader->backgroundlayer->framerate;
-				for (j = 0;j < shader->backgroundlayer->numframes;j++)
-				{
-					if (!(out->backgroundskinframes[j] = R_SkinFrame_LoadExternal(shader->backgroundlayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | ((!r_picmipworld.integer || (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP)) ? 0 : TEXF_PICMIP) | (shader->backgroundlayer->clampmap ? TEXF_CLAMP : 0), false)))
-					{
-						Con_DPrintf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->backgroundlayer->texturename[j], j, out->name);
-						out->backgroundskinframes[j] = R_SkinFrame_LoadMissing();
-					}
-				}
-			}
-		}
-		else if (!strcmp(out->name, "noshader"))
-			out->surfaceparms = 0;
-		else
-		{
-			c++;
-			Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name);
-			out->surfaceparms = 0;
-			if (out->surfaceflags & Q3SURFACEFLAG_NODRAW)
-				out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
-			else if (out->surfaceflags & Q3SURFACEFLAG_SKY)
-				out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
-			else
-				out->basematerialflags |= MATERIALFLAG_WALL;
-			// these are defaults
-			//if (!strncmp(out->name, "textures/skies/", 15))
-			//	out->surfaceparms |= Q3SURFACEPARM_SKY;
-			//if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
-			// || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
-			//	out->surfaceparms |= Q3SURFACEPARM_NODRAW;
-			//if (R_TextureHasAlpha(out->skinframes[0].base))
-			//	out->surfaceparms |= Q3SURFACEPARM_TRANS;
-			out->numskinframes = 1;
-			if (!(out->skinframes[0] = R_SkinFrame_LoadExternal(out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false)))
-				Con_DPrintf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name);
-		}
-		// init the animation variables
-		out->currentframe = out;
-		if (out->numskinframes < 1)
-			out->numskinframes = 1;
-		if (!out->skinframes[0])
-			out->skinframes[0] = R_SkinFrame_LoadMissing();
-		out->currentskinframe = out->skinframes[0];
-		out->backgroundcurrentskinframe = out->backgroundskinframes[0];
-	}
-	if (c)
-		Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
+		Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
 }
 
 static void Mod_Q3BSP_LoadPlanes(lump_t *l)
@@ -4824,8 +4423,9 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 {
 	q3dlightmap_t *in;
-	int i, j, count, power, power2, mask, endlightmap;
+	int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
 	unsigned char *c;
+	unsigned char convertedpixels[128*128*4];
 
 	if (!l->filelen)
 		return;
@@ -4867,14 +4467,15 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 			}
 		}
 	}
-	if (endlightmap < 2)
-		loadmodel->brushq3.deluxemapping = false;
 
 	// q3map2 sometimes (or always?) makes a second blank lightmap for no
 	// reason when only one lightmap is used, which can throw off the
 	// deluxemapping detection method, so check 2-lightmap bsp's specifically
 	// to see if the second lightmap is blank, if so it is not deluxemapped.
-	if (endlightmap == 1 && count == 2)
+	//
+	// further research has shown q3map2 sometimes creates a deluxemap and two
+	// 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++)
@@ -4891,7 +4492,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 
 	// figure out what the most reasonable merge power is within limits
 	loadmodel->brushq3.num_lightmapmergepower = 0;
-	for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (1 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++)
+	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;
 	loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower;
 
@@ -4904,25 +4505,58 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 	if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
 		loadmodel->texturepool = R_AllocTexturePool();
 
-	j = 128 << loadmodel->brushq3.num_lightmapmergepower;
-	if (loadmodel->brushq3.data_lightmaps)
-		for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++)
-			loadmodel->brushq3.data_lightmaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
-
-	if (loadmodel->brushq3.data_deluxemaps)
-		for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++)
-			loadmodel->brushq3.data_deluxemaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
-
 	power = loadmodel->brushq3.num_lightmapmergepower;
 	power2 = power * 2;
 	mask = (1 << power) - 1;
 	for (i = 0;i < count;i++)
 	{
-		j = i >> loadmodel->brushq3.deluxemapping;
-		if (loadmodel->brushq3.deluxemapping && (i & 1))
-			R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128);
+		// figure out which merged lightmap texture this fits into
+		int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2);
+		for (k = 0;k < 128*128;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+3] = 255;
+		}
+		if (loadmodel->brushq3.num_lightmapmergepower > 0)
+		{
+			// if the lightmap has not been allocated yet, create it
+			if (!loadmodel->brushq3.data_lightmaps[lightmapindex])
+			{
+				// create a lightmap only as large as necessary to hold the
+				// remaining 128x128 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
+				// be odd sizes like 2048x512 due to only being 25% full or so.
+				j = (count >> loadmodel->brushq3.deluxemapping) - (lightmapindex << power2);
+				for (mergewidth = 1;mergewidth < j && mergewidth < (1 << power);mergewidth *= 2)
+					;
+				for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2)
+					;
+				if (developer_loading.integer)
+					Con_Printf("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 (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);
+			}
+			mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
+			mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
+			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);
+			else
+				R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+		}
 		else
-			R_UpdateTexture(loadmodel->brushq3.data_lightmaps [j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128);
+		{
+			// 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);
+			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);
+		}
 	}
 }
 
@@ -4931,7 +4565,7 @@ 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;
-	float lightmaptcbase[2], lightmaptcscale;
+	float lightmaptcbase[2], lightmaptcscale[2];
 	//int *originalelement3i;
 	//int *originalneighbor3i;
 	float *originalvertex3f;
@@ -4962,7 +4596,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)
@@ -5031,7 +4665,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		}
 		switch(type)
 		{
-		case Q3FACETYPE_POLYGON:
+		case Q3FACETYPE_FLAT:
 		case Q3FACETYPE_MESH:
 			// no processing necessary
 			break;
@@ -5096,7 +4730,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++)
@@ -5228,18 +4862,22 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		VectorClear(out->maxs);
 		if (out->num_vertices)
 		{
-			int lightmapindex = LittleLong(in->lightmapindex);
-			if (lightmapindex >= 0 && cls.state != ca_dedicated)
+			if (cls.state != ca_dedicated && out->lightmaptexture)
 			{
-				lightmapindex >>= loadmodel->brushq3.deluxemapping;
-				lightmaptcscale = 1.0f / loadmodel->brushq3.num_lightmapmerge;
-				lightmaptcbase[0] = ((lightmapindex                                             ) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale;
-				lightmaptcbase[1] = ((lightmapindex >> loadmodel->brushq3.num_lightmapmergepower) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale;
+				// 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;
+				lightmapindex &= mergewidth * mergeheight - 1;
+				lightmaptcscale[0] = 1.0f / mergewidth;
+				lightmaptcscale[1] = 1.0f / mergeheight;
+				lightmaptcbase[0] = (lightmapindex % mergewidth) * lightmaptcscale[0];
+				lightmaptcbase[1] = (lightmapindex / mergewidth) * lightmaptcscale[1];
 				// modify the lightmap texcoords to match this region of the merged lightmap
 				for (j = 0, v = loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex;j < out->num_vertices;j++, v += 2)
 				{
-					v[0] = v[0] * lightmaptcscale + lightmaptcbase[0];
-					v[1] = v[1] * lightmaptcscale + lightmaptcbase[1];
+					v[0] = v[0] * lightmaptcscale[0] + lightmaptcbase[0];
+					v[1] = v[1] * lightmaptcscale[1] + lightmaptcbase[1];
 				}
 			}
 			VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->mins);
@@ -5270,6 +4908,11 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	// 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)
@@ -5545,11 +5188,11 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l)
 static void Mod_Q3BSP_LightPoint(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, yaw, pitch, sinpitch, stylescale;
+	float transformed[3], blend1, blend2, blend, stylescale;
 	q3dlightgrid_t *a, *s;
 
 	// scale lighting by lightstyle[0] so that darkmode in dpmod works properly
-	stylescale = r_refdef.lightstylevalue[0] * (1.0f / 264.0f);
+	stylescale = r_refdef.scene.rtlightstylevalue[0];
 
 	if (!model->brushq3.num_lightgrid)
 	{
@@ -5591,12 +5234,12 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc
 				s = a + (k * model->brushq3.num_lightgrid_isize[1] + j) * model->brushq3.num_lightgrid_isize[0] + i;
 				VectorMA(ambientcolor, blend * (1.0f / 128.0f), s->ambientrgb, ambientcolor);
 				VectorMA(diffusecolor, blend * (1.0f / 128.0f), s->diffusergb, diffusecolor);
-				pitch = s->diffusepitch * M_PI / 128;
-				yaw = s->diffuseyaw * M_PI / 128;
-				sinpitch = sin(pitch);
-				diffusenormal[0] += blend * (cos(yaw) * sinpitch);
-				diffusenormal[1] += blend * (sin(yaw) * sinpitch);
-				diffusenormal[2] += blend * (cos(pitch));
+				// this uses the mod_md3_sin table because the values are
+				// already in the 0-255 range, the 64+ bias fetches a cosine
+				// instead of a sine value
+				diffusenormal[0] += blend * (mod_md3_sin[64 + s->diffuseyaw] * mod_md3_sin[s->diffusepitch]);
+				diffusenormal[1] += blend * (mod_md3_sin[     s->diffuseyaw] * mod_md3_sin[s->diffusepitch]);
+				diffusenormal[2] += blend * (mod_md3_sin[64 + s->diffusepitch]);
 				//Con_Printf("blend %f: ambient %i %i %i, diffuse %i %i %i, diffusepitch %i diffuseyaw %i (%f %f, normal %f %f %f)\n", blend, s->ambientrgb[0], s->ambientrgb[1], s->ambientrgb[2], s->diffusergb[0], s->diffusergb[1], s->diffusergb[2], s->diffusepitch, s->diffuseyaw, pitch, yaw, (cos(yaw) * cospitch), (sin(yaw) * cospitch), (-sin(pitch)));
 			}
 		}
@@ -5614,7 +5257,7 @@ static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model
 	colbrushf_t *brush;
 	// find which leaf the point is in
 	while (node->plane)
-		node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
+		node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
 	// point trace the brushes
 	leaf = (mleaf_t *)node;
 	for (i = 0;i < leaf->numleafbrushes;i++)
@@ -5877,6 +5520,38 @@ static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const
 	}
 }
 
+static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+	int i;
+	int supercontents = 0;
+	q3mbrush_t *brush;
+	// test if the point is inside each brush
+	if (model->brush.submodel)
+	{
+		// submodels are effectively one leaf
+		for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+			if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+				supercontents |= brush->colbrushf->supercontents;
+	}
+	else
+	{
+		mnode_t *node = model->brush.data_nodes;
+		mleaf_t *leaf;
+		// find which leaf the point is in
+		while (node->plane)
+			node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
+		leaf = (mleaf_t *)node;
+		// now check the brushes in the leaf
+		for (i = 0;i < leaf->numleafbrushes;i++)
+		{
+			brush = model->brush.data_brushes + leaf->firstleafbrush[i];
+			if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+				supercontents |= brush->colbrushf->supercontents;
+		}
+	}
+	return supercontents;
+}
+
 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
 {
 	int supercontents = 0;
@@ -5949,6 +5624,8 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	float corner[3], yawradius, modelradius;
 	msurface_t *surface;
 
+	mod->modeldatatypestring = "Q3BSP";
+
 	mod->type = mod_brushq3;
 	mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
 	mod->numskins = 1;
@@ -5959,15 +5636,12 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	if (i != Q3BSPVERSION)
 		Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
 	mod->brush.ishlbsp = false;
-	mod->brush.ismcbsp = false;
 	if (loadmodel->isworldmodel)
-	{
 		Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
-		Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
-	}
 
 	mod->soundfromcenter = true;
 	mod->TraceBox = Mod_Q3BSP_TraceBox;
+	mod->PointSuperContents = Mod_Q3BSP_PointSuperContents;
 	mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
 	mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
 	mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
@@ -5981,10 +5655,13 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
 	mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
 	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;
+	mod->DrawAddWaterPlanes = NULL;
 
 	mod_base = (unsigned char *)header;
 
@@ -6051,14 +5728,6 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	loadmodel->brush.num_leafs = 0;
 	Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
 
-	if (loadmodel->isworldmodel)
-	{
-		// clear out any stale submodels or worldmodels lying around
-		// if we did this clear before now, an error might abort loading and
-		// leave things in a bad state
-		Mod_RemoveStaleWorldModels(loadmodel);
-	}
-
 	mod = loadmodel;
 	for (i = 0;i < loadmodel->brush.numsubmodels;i++)
 	{
@@ -6101,6 +5770,30 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
 		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]));
@@ -6116,12 +5809,20 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		mod->radius2 = modelradius * modelradius;
 
 		for (j = 0;j < mod->nummodelsurfaces;j++)
-			if (mod->data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY)
+			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;
 	}
 }