X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=1b0cc330d4ecf813e5f97d7303494ddbceb578b1;hp=6c776b30935edbdea97a32a629fd419f75da6b2a;hb=3c8da461b7565f9c6524c48aecc362270815c3ee;hpb=a255e13ec710fbfbf541ef09b2195253dea80658

diff --git a/model_brush.c b/model_brush.c
index 6c776b30..1b0cc330 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -28,9 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "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 = {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)"};
@@ -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 = 0;
+	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,19 +1358,28 @@ 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)
@@ -1486,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);
@@ -1510,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
@@ -1668,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
@@ -1761,13 +1774,13 @@ static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
 	int i, j, k;
 	if (!data)
 		return;
-	if (!COM_ParseToken_Simple(&data, false))
+	if (!COM_ParseToken_Simple(&data, false, false))
 		return; // error
 	if (com_token[0] != '{')
 		return; // error
 	while (1)
 	{
-		if (!COM_ParseToken_Simple(&data, false))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			return; // error
 		if (com_token[0] == '}')
 			break; // end of worldspawn
@@ -1777,7 +1790,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_ParseToken_Simple(&data, false))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			return; // error
 		dpsnprintf(value, sizeof(value), "%s", com_token);
 		if (!strcmp("wad", key)) // for HalfLife maps
@@ -1972,7 +1985,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
@@ -2136,34 +2149,67 @@ 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;
 }
 
@@ -2174,9 +2220,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	msurface_t *surface;
 	int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples;
 	float texmins[2], texmaxs[2], val;
-#define LIGHTMAPSIZE 1024
 	rtexture_t *lightmaptexture, *deluxemaptexture;
-	int lightmap_lineused[LIGHTMAPSIZE];
 
 	in = (dface_t *)(mod_base + l->fileofs);
 	if (l->filelen % sizeof(*in))
@@ -2191,7 +2235,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;
 	}
@@ -2201,7 +2245,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	lightmaptexture = NULL;
 	deluxemaptexture = r_texture_blanknormalmap;
 	lightmapnumber = 1;
-	lightmapsize = bound(256, gl_max_size.integer, LIGHTMAPSIZE);
+	lightmapsize = max(256, gl_max_size.integer);
 	totallightmapsamples = 0;
 
 	totalverts = 0;
@@ -2212,16 +2256,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);
 
@@ -2300,7 +2344,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;
@@ -2345,69 +2389,65 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 	// store
 	// additionally, never choose a lightmapsize that is smaller than the
 	// largest surface encountered (as it would fail)
-	// and finally, limit it to the size of our lineused array
 	i = lightmapsize;
-	for (lightmapsize = 64;lightmapsize < LIGHTMAPSIZE && (lightmapsize < i || (lightmapsize < gl_max_size.integer && totallightmapsamples*2 > lightmapsize*lightmapsize));lightmapsize*=2)
+	for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2)
 		;
 
 	// 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++)
 		{
-			// check if we should apply a lightmap to this
-			if (surface->cached_dlight)
+			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;
+			
+			// stainmap for permanent marks on walls
+			surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+			// clear to white
+			memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
+
+			if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
 			{
-				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;
-
-				// 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);
-
-				// find a place for this lightmap
-				if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
-				{
-					// allocate a texture pool if we need it
-					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);
-					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);
-					lightmapnumber++;
-					memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
-					Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
-				}
-
-				surface->lightmaptexture = lightmaptexture;
-				surface->deluxemaptexture = deluxemaptexture;
-				surface->lightmapinfo->lightmaporigin[0] = lightmapx;
-				surface->lightmapinfo->lightmaporigin[1] = lightmapy;
+				// allocate a texture pool if we need it
+				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, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+				if (loadmodel->brushq1.nmaplightdata)
+					deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+				lightmapnumber++;
+				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;
 
-				uscale = 1.0f / (float)lightmapsize;
-				vscale = 1.0f / (float)lightmapsize;
-				ubase = lightmapx * uscale;
-				vbase = lightmapy * vscale;
+			uscale = 1.0f / (float)lightmapsize;
+			vscale = 1.0f / (float)lightmapsize;
+			ubase = lightmapx * uscale;
+			vbase = lightmapy * vscale;
 
-				for (i = 0;i < surface->num_vertices;i++)
-				{
-					u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
-					v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
-					(loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
-					(loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
-					// LordHavoc: calc lightmap data offset for vertex lighting to use
-					iu = (int) u;
-					iv = (int) v;
-					(loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
-				}
+			for (i = 0;i < surface->num_vertices;i++)
+			{
+				u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
+				v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
+				(loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
+				(loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
+				// LordHavoc: calc lightmap data offset for vertex lighting to use
+				iu = (int) u;
+				iv = (int) v;
+				(loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
 			}
+
 		}
 	}
 }
@@ -2475,16 +2515,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;
+				}
+			}
 		}
 	}
 
@@ -2523,9 +2587,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;
@@ -2575,7 +2639,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;
 
@@ -2583,12 +2648,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;
@@ -2607,12 +2672,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)");
 	}
 }
 
@@ -2620,14 +2688,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;
@@ -2655,7 +2723,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;
@@ -2716,12 +2784,12 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 	if (!maptext)
 		return;
 	text = maptext;
-	if (!COM_ParseToken_Simple(&data, false))
+	if (!COM_ParseToken_Simple(&data, false, false))
 		return; // error
 	submodel = 0;
 	for (;;)
 	{
-		if (!COM_ParseToken_Simple(&data, false))
+		if (!COM_ParseToken_Simple(&data, false, false))
 			break;
 		if (com_token[0] != '{')
 			return; // error
@@ -2732,7 +2800,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 		brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
 		for (;;)
 		{
-			if (!COM_ParseToken_Simple(&data, false))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				return; // error
 			if (com_token[0] == '}')
 				break; // end of entity
@@ -2756,7 +2824,7 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 				}
 				for (;;)
 				{
-					if (!COM_ParseToken_Simple(&data, false))
+					if (!COM_ParseToken_Simple(&data, false, false))
 						return; // error
 					if (com_token[0] == '}')
 						break; // end of brush
@@ -2765,25 +2833,25 @@ static void Mod_Q1BSP_LoadMapBrushes(void)
 					// FIXME: support hl .map format
 					for (pointnum = 0;pointnum < 3;pointnum++)
 					{
-						COM_ParseToken_Simple(&data, false);
+						COM_ParseToken_Simple(&data, false, false);
 						for (componentnum = 0;componentnum < 3;componentnum++)
 						{
-							COM_ParseToken_Simple(&data, false);
+							COM_ParseToken_Simple(&data, false, false);
 							point[pointnum][componentnum] = atof(com_token);
 						}
-						COM_ParseToken_Simple(&data, false);
+						COM_ParseToken_Simple(&data, false, false);
 					}
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					strlcpy(facetexture, com_token, sizeof(facetexture));
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					//scroll_s = atof(com_token);
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					//scroll_t = atof(com_token);
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					//rotate = atof(com_token);
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					//scale_s = atof(com_token);
-					COM_ParseToken_Simple(&data, false);
+					COM_ParseToken_Simple(&data, false, false);
 					//scale_t = atof(com_token);
 					TriangleNormal(point[0], point[1], point[2], planenormal);
 					VectorNormalizeDouble(planenormal);
@@ -3185,59 +3253,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)
@@ -3280,7 +3295,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);
@@ -3289,7 +3304,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;
 }
@@ -3300,16 +3316,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
@@ -3345,100 +3352,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->modeldatatypestring = "Q1BSP";
 
 	mod->type = mod_brushq1;
 
-	if (!memcmp (buffer, "MCBSPpad", 8))
-	{
-		unsigned char	*index;
-
-		mod->brush.ismcbsp = true;
-		mod->brush.ishlbsp = false;
+	header = (dheader_t *)buffer;
 
-		mod_base = (unsigned char*)buffer;
-
-		index = mod_base;
-		index += 8;
-		i = SB_ReadInt (&index);
-		if (i != MCBSPVERSION)
-			Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
-
-	// read hull info
-		hullinfo.numhulls = LittleLong(*(int*)index); index += 4;
-		hullinfo.filehulls = hullinfo.numhulls;
-		VectorClear (hullinfo.hullsizes[0][0]);
-		VectorClear (hullinfo.hullsizes[0][1]);
-		for (i = 1; i < hullinfo.numhulls; i++)
-		{
-			hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
-			hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
-		}
+	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)
-		{
-			mod->modeldatatypestring = "HLBSP";
-
-			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;
@@ -3455,16 +3419,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++)
@@ -3526,14 +3484,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:
@@ -3548,6 +3498,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
@@ -3591,7 +3560,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		mod->nummodelsurfaces = bm->numfaces;
 
 		// make the model surface list (used by shadowing/lighting)
-		mod->surfacelist = (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;
 
@@ -3600,6 +3569,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 		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;
@@ -3616,7 +3586,6 @@ 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);
 		if (mod->nummodelsurfaces)
 		{
 			// LordHavoc: calculate bmodel bounding box rather than trusting what it says
@@ -3629,7 +3598,7 @@ 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_WATERALPHA)
+				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)
@@ -3657,6 +3626,44 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = 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
 		{
@@ -4069,12 +4076,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;
 
@@ -4082,9 +4085,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++)
@@ -4135,11 +4135,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_ParseToken_Simple(&data, false) && com_token[0] == '{')
+	if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{')
 	{
 		while (1)
 		{
-			if (!COM_ParseToken_Simple(&data, false))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				break; // error
 			if (com_token[0] == '}')
 				break; // end of worldspawn
@@ -4149,7 +4149,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_ParseToken_Simple(&data, false))
+			if (!COM_ParseToken_Simple(&data, false, false))
 				break; // error
 			strlcpy(value, com_token, sizeof(value));
 			if (!strcmp("gridsize", key))
@@ -4189,7 +4189,7 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 
 	c = 0;
 	for (i = 0;i < count;i++, in++, out++)
-		if (Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false))
+		if (!Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false))
 			c++;
 	if (c)
 		Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
@@ -4395,8 +4395,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, mergewidth, mergeheight;
+	int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
 	unsigned char *c;
+	unsigned char convertedpixels[128*128*4];
 
 	if (!l->filelen)
 		return;
@@ -4438,14 +4439,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++)
@@ -4475,15 +4477,22 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 	if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
 		loadmodel->texturepool = R_AllocTexturePool();
 
-	if (loadmodel->brushq3.num_lightmapmergepower > 0)
+	power = loadmodel->brushq3.num_lightmapmergepower;
+	power2 = power * 2;
+	mask = (1 << power) - 1;
+	for (i = 0;i < count;i++)
 	{
-		power = loadmodel->brushq3.num_lightmapmergepower;
-		power2 = power * 2;
-		mask = (1 << power) - 1;
-		for (i = 0;i < count;i++)
+		// 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)
 		{
-			// figure out which merged lightmap texture this fits into
-			int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2);
 			// if the lightmap has not been allocated yet, create it
 			if (!loadmodel->brushq3.data_lightmaps[lightmapindex])
 			{
@@ -4499,29 +4508,25 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 				for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2)
 					;
 				Con_DPrintf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*128, mergeheight*128, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
-				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), 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_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+					loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * 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], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+				R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
 			else
-				R_UpdateTexture(loadmodel->brushq3.data_lightmaps     [lightmapindex], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+				R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
 		}
-	}
-	else
-	{
-		for (i = 0;i < count;i++)
+		else
 		{
 			// figure out which merged lightmap texture this fits into
-			int lightmapindex = i >> loadmodel->brushq3.deluxemapping;
 			if (loadmodel->brushq3.deluxemapping && (i & 1))
-				loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), 128, 128, in[i].rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), 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, in[i].rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), 128, 128, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
 		}
 	}
 }
@@ -5153,7 +5158,7 @@ static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientc
 	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)
 	{
@@ -5218,7 +5223,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++)
@@ -5481,6 +5486,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;
@@ -5565,15 +5602,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;
@@ -5588,6 +5622,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 	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;
@@ -5659,14 +5694,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++)
 	{
@@ -5732,7 +5759,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 			mod->DrawSky = NULL;
 
 		for (j = 0;j < mod->nummodelsurfaces;j++)
-			if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_WATERALPHA)
+			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;