X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_brush.c;h=ee82cde804626d0f89e6b4be8af67bf734b2e1d0;hp=5cfae1538aef90840d14358b2e95847261633e01;hb=a5c12e5524c2af491c483e0207f48524f1cf072a;hpb=4ba615858bc88fb2467a16c97126462d4dfc3b53

diff --git a/model_brush.c b/model_brush.c
index 5cfae153..ee82cde8 100644
--- a/model_brush.c
+++ b/model_brush.c
@@ -46,6 +46,7 @@ cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "select
 cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."};
 cvar_t mod_q3bsp_nolightmaps = {CVAR_SAVE, "mod_q3bsp_nolightmaps", "0", "do not load lightmaps in Q3BSP maps (to save video RAM, but be warned: it looks ugly)"};
 cvar_t mod_q3bsp_tracelineofsight_brushes = {0, "mod_q3bsp_tracelineofsight_brushes", "0", "enables culling of entities behind detail brushes, curves, etc"};
+cvar_t mod_collision_bih = {0, "mod_collision_bih", "0", "enables use of generated Bounding Interval Hierarchy tree instead of compiled bsp tree in collision code"};
 
 static texture_t mod_q1bsp_texture_solid;
 static texture_t mod_q1bsp_texture_sky;
@@ -75,6 +76,7 @@ void Mod_BrushInit(void)
 	Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
 	Cvar_RegisterVariable(&mod_q3bsp_nolightmaps);
 	Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes);
+	Cvar_RegisterVariable(&mod_collision_bih);
 
 	memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
 	strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
@@ -522,17 +524,17 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in
 		surface = info->model->data_surfaces + *mark;
 		if (surface->texture->supercontents & SUPERCONTENTS_SOLID)
 		{
-			if(surface->num_bboxstride > 0)
+			if(surface->deprecatedq3num_bboxstride > 0)
 			{
 				int i, cnt, tri;
-				cnt = (surface->num_triangles + surface->num_bboxstride - 1) / surface->num_bboxstride;
+				cnt = (surface->num_triangles + surface->deprecatedq3num_bboxstride - 1) / surface->deprecatedq3num_bboxstride;
 				for(i = 0; i < cnt; ++i)
 				{
-					if(BoxesOverlap(surface->data_bbox6f + i * 6, surface->data_bbox6f + i * 6 + 3, info->absmin, info->absmax))
+					if(BoxesOverlap(surface->deprecatedq3data_bbox6f + i * 6, surface->deprecatedq3data_bbox6f + i * 6 + 3, info->absmin, info->absmax))
 					{
-						for(k = 0; k < surface->num_bboxstride; ++k)
+						for(k = 0; k < surface->deprecatedq3num_bboxstride; ++k)
 						{
-							tri = i * surface->num_bboxstride + k;
+							tri = i * surface->deprecatedq3num_bboxstride + k;
 							if(tri >= surface->num_triangles)
 								break;
 							Mod_Q1BSP_FindNonSolidLocation_r_Triangle(info, surface, tri);
@@ -1017,7 +1019,7 @@ static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const
 	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)
+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, const texture_t *boxtexture)
 {
 #if 1
 	colbrushf_t cbox;
@@ -1123,7 +1125,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm
 #endif
 }
 
-void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
+void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture)
 {
 	memset(trace, 0, sizeof(trace_t));
 	trace->fraction = 1;
@@ -1209,7 +1211,7 @@ loc0:
 			surface = model->data_surfaces + node->firstsurface;
 			for (i = 0;i < node->numsurfaces;i++, surface++)
 			{
-				if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples)
+				if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo || !surface->lightmapinfo->samples)
 					continue;	// no lightmaps
 
 				// location we want to sample in the lightmap
@@ -1381,8 +1383,8 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp
 		}
 	}
 
-	loadmodel->brush.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture",              TEXF_PRECACHE, (unsigned char *) solidpixels, w, h);
-	loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA | TEXF_PRECACHE, (unsigned char *) alphapixels, w, h);
+	loadmodel->brush.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", 0         , (unsigned char *) solidpixels, w, h);
+	loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA, (unsigned char *) alphapixels, w, h);
 	Mem_Free(solidpixels);
 	Mem_Free(alphapixels);
 }
@@ -1567,7 +1569,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			// LordHavoc: HL sky textures are entirely different than quake
 			if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == mtheight * 2)
 			{
-				data = loadimagepixelsbgra(tx->name, false, false);
+				data = loadimagepixelsbgra(tx->name, false, false, r_texture_convertsRGB_skin.integer);
 				if (data && image_width == image_height * 2)
 				{
 					R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
@@ -1578,9 +1580,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_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+				skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | (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_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+					skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
 				if (!skinframe)
 				{
 					// did not find external texture, load it from the bsp or wad3
@@ -1597,13 +1599,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 						{
 							tx->width = image_width;
 							tx->height = image_height;
-							skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
+							skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
 						}
 						if (freepixels)
 							Mem_Free(freepixels);
 					}
 					else if (mtdata) // texture included
-						skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_PRECACHE | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
+						skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | (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)
@@ -1618,7 +1620,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 				{
 					// 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->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zero, 1, 1);
 					tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION;
 				}
 				else if (!strncmp(tx->name,"*lava",5)
@@ -1633,7 +1635,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l)
 			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->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, zero, 1, 1);
 				tx->basematerialflags |= MATERIALFLAG_REFLECTION;
 			}
 			else if (!strncmp(tx->name, "sky", 3))
@@ -2248,6 +2250,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 
 	loadmodel->num_surfaces = count;
 
+	loadmodel->brushq1.firstrender = true;
 	loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char));
 
 	totalverts = 0;
@@ -2444,9 +2447,9 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
 				loadmodel->brushq3.num_mergedlightmaps = lightmapnumber + 1;
 				loadmodel->brushq3.data_lightmaps = Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_lightmaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_lightmaps[0]));
 				loadmodel->brushq3.data_deluxemaps = Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_deluxemaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_deluxemaps[0]));
-				loadmodel->brushq3.data_lightmaps[lightmapnumber] = lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | TEXF_ALLOWUPDATES | TEXF_MANUALFLUSHUPDATES, NULL);
+				loadmodel->brushq3.data_lightmaps[lightmapnumber] = lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, NULL);
 				if (loadmodel->brushq1.nmaplightdata)
-					loadmodel->brushq3.data_deluxemaps[lightmapnumber] = deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | TEXF_ALLOWUPDATES | TEXF_MANUALFLUSHUPDATES, NULL);
+					loadmodel->brushq3.data_deluxemaps[lightmapnumber] = deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, NULL);
 				lightmapnumber++;
 				Mod_AllocLightmap_Reset(&allocState);
 				Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy);
@@ -3401,7 +3404,6 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 	int i, j, k;
 	dheader_t *header;
 	dmodel_t *bm;
-	mempool_t *mainmempool;
 	float dist, modelyawradius, modelradius;
 	msurface_t *surface;
 	int numshadowmeshtriangles;
@@ -3489,12 +3491,15 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 	mod->brush.qw_md4sum2 = 0;
 	for (i = 0;i < HEADER_LUMPS;i++)
 	{
+		int temp;
 		if (i == LUMP_ENTITIES)
 			continue;
-		mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
+		temp = Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+		mod->brush.qw_md4sum ^= LittleLong(temp);
 		if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
 			continue;
-		mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
+		temp = Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+		mod->brush.qw_md4sum2 ^= LittleLong(temp);
 	}
 
 	Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]);
@@ -3528,8 +3533,6 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 	mod->numframes = 2;		// regular and alternate animation
 	mod->numskins = 1;
 
-	mainmempool = mod->mempool;
-
 	// make a single combined shadow mesh to allow optimized shadow volume creation
 	numshadowmeshtriangles = 0;
 	for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
@@ -3716,14 +3719,17 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 			Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
 		}
 		//mod->brushq1.num_visleafs = bm->visleafs;
-	}
-
-	Mod_Q1BSP_LoadMapBrushes();
 
-	//Mod_Q1BSP_ProcessLightList();
+		// generate VBOs and other shared data before cloning submodels
+		if (i == 0)
+		{
+			Mod_BuildVBOs();
+			Mod_Q1BSP_LoadMapBrushes();
+			//Mod_Q1BSP_ProcessLightList();
+		}
+	}
 
-	if (developer.integer >= 10)
-		Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals);
+	Con_DPrintf("Stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces);
 }
 
 static void Mod_Q2BSP_LoadEntities(lump_t *l)
@@ -4257,7 +4263,7 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l)
 		return;
 
 	for (i = 0;i < count;i++, in++, out++)
-		Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
+		Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
 }
 
 static void Mod_Q3BSP_LoadPlanes(lump_t *l)
@@ -4474,8 +4480,16 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 	if (l->filelen % sizeof(int[3]))
 		Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
 	count = l->filelen / sizeof(*in);
-	out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 
+	if(!loadmodel->brushq3.num_vertices)
+	{
+		if (count)
+			Con_Printf("Mod_Q3BSP_LoadTriangles: %s has triangles but no vertexes, broken compiler, ignoring problem\n", loadmodel->name);
+		loadmodel->brushq3.num_triangles = 0;
+		return;
+	}
+
+	out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
 	loadmodel->brushq3.num_triangles = count / 3;
 	loadmodel->brushq3.data_element3i = out;
 
@@ -4485,8 +4499,6 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 		if (*out < 0 || *out >= loadmodel->brushq3.num_vertices)
 		{
 			Con_Printf("Mod_Q3BSP_LoadTriangles: invalid vertexindex %i (%i vertices), setting to 0\n", *out, loadmodel->brushq3.num_vertices);
-			if(!loadmodel->brushq3.num_vertices)
-				Host_Error("Mod_Q1BSP_LoadTrianglles: %s has triangles but no vertexes, cannot fix\n", loadmodel->name);
 			*out = 0;
 		}
 	}
@@ -4495,7 +4507,7 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l)
 static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 {
 	q3dlightmap_t *input_pointer;
-	int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
+	int i, j, k, count, power, power2, endlightmap, mergewidth, mergeheight;
 	unsigned char *c;
 
 	unsigned char *convertedpixels;
@@ -4539,7 +4551,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 		if (developer_loading.integer)
 			Con_Printf("Using external lightmaps\n");
 		FS_StripExtension(loadmodel->name, mapname, sizeof(mapname));
-		inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false);
+		inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false, false);
 		if(!inpixels[0])
 			return;
 
@@ -4559,7 +4571,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 
 		for(count = 1; ; ++count)
 		{
-			inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false);
+			inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false, false);
 			if(!inpixels[count])
 				break; // we got all of them
 			if(image_width != size || image_height != size)
@@ -4663,7 +4675,6 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 
 	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
@@ -4693,9 +4704,9 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 					;
 				if (developer_loading.integer)
 					Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
-				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES | TEXF_MANUALFLUSHUPDATES), NULL);
+				loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES), NULL);
 				if (loadmodel->brushq3.data_deluxemaps)
-					loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES | TEXF_MANUALFLUSHUPDATES), NULL);
+					loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES), NULL);
 			}
 			mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
 			mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
@@ -4709,20 +4720,12 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
 		{
 			// 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), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
 			else
-				loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+				loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
 		}
 	}
 
-	for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++)
-	{
-		if (loadmodel->brushq3.data_deluxemaps[i])
-			R_FlushTexture(loadmodel->brushq3.data_deluxemaps[i]);
-		if (loadmodel->brushq3.data_lightmaps[i])
-			R_FlushTexture(loadmodel->brushq3.data_lightmaps[i]);
-	}
-
 	Mem_Free(convertedpixels);
 	if(external)
 	{
@@ -4802,7 +4805,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, cxtess, cytess;
+	int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, collisionvertices, collisiontriangles, numvertices, numtriangles, cxtess, cytess;
 	float lightmaptcbase[2], lightmaptcscale[2];
 	//int *originalelement3i;
 	//int *originalneighbor3i;
@@ -4813,6 +4816,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	float *originalcolor4f;
 	float *originaltexcoordtexture2f;
 	float *originaltexcoordlightmap2f;
+	float *surfacecollisionvertex3f;
+	int *surfacecollisionelement3i;
 	float *v;
 	patchtess_t *patchtess = NULL;
 	int patchtesscount = 0;
@@ -4859,8 +4864,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		n = LittleLong(in->effectindex);
 		if (n < -1 || n >= loadmodel->brushq3.num_effects)
 		{
-			if (developer.integer >= 100)
-				Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
+			if (developer_extra.integer)
+				Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
 			n = -1;
 		}
 		if (n == -1)
@@ -4954,18 +4959,18 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	 		patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess;
 	
 			patchtess[patchtesscount].surface_id = i;
-			patchtess[patchtesscount].lodgroup[0] = in->specific.patch.mins[0];
-			patchtess[patchtesscount].lodgroup[1] = in->specific.patch.mins[1];
-			patchtess[patchtesscount].lodgroup[2] = in->specific.patch.mins[2];
-			patchtess[patchtesscount].lodgroup[3] = in->specific.patch.maxs[0];
-			patchtess[patchtesscount].lodgroup[4] = in->specific.patch.maxs[1];
-			patchtess[patchtesscount].lodgroup[5] = in->specific.patch.maxs[2];
+			patchtess[patchtesscount].lodgroup[0] = LittleFloat(in->specific.patch.mins[0]);
+			patchtess[patchtesscount].lodgroup[1] = LittleFloat(in->specific.patch.mins[1]);
+			patchtess[patchtesscount].lodgroup[2] = LittleFloat(in->specific.patch.mins[2]);
+			patchtess[patchtesscount].lodgroup[3] = LittleFloat(in->specific.patch.maxs[0]);
+			patchtess[patchtesscount].lodgroup[4] = LittleFloat(in->specific.patch.maxs[1]);
+			patchtess[patchtesscount].lodgroup[5] = LittleFloat(in->specific.patch.maxs[2]);
 			patchtess[patchtesscount].originalvertex3f = originalvertex3f;
 			++patchtesscount;
 			break;
 		case Q3FACETYPE_FLARE:
-			if (developer.integer >= 100)
-				Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
+			if (developer_extra.integer)
+				Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
 			// don't render it
 			continue;
 		}
@@ -4994,6 +4999,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 	while (again);
 
 	// Calculate resulting number of triangles
+	collisionvertices = 0;
+	collisiontriangles = 0;
 	for(i = 0; i < patchtesscount; ++i)
 	{
 		finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess);
@@ -5005,14 +5012,31 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		oldout[patchtess[i].surface_id].num_triangles = numtriangles;
 		meshvertices += oldout[patchtess[i].surface_id].num_vertices;
 		meshtriangles += oldout[patchtess[i].surface_id].num_triangles;
+
+		finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_COLLISION].xtess);
+		finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_COLLISION].ytess);
+		numvertices = finalwidth * finalheight;
+		numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+
+		oldout[patchtess[i].surface_id].num_collisionvertices = numvertices;
+		oldout[patchtess[i].surface_id].num_collisiontriangles = numtriangles;
+		collisionvertices += oldout[patchtess[i].surface_id].num_collisionvertices;
+		collisiontriangles += oldout[patchtess[i].surface_id].num_collisiontriangles;
 	}
 
 	i = oldi;
 	in = oldin;
 	out = oldout;
 	Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false);
+	if (collisiontriangles)
+	{
+		loadmodel->brush.data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, collisionvertices * sizeof(float[3]));
+		loadmodel->brush.data_collisionelement3i = Mem_Alloc(loadmodel->mempool, collisiontriangles * sizeof(int[3]));
+	}
 	meshvertices = 0;
 	meshtriangles = 0;
+	collisionvertices = 0;
+	collisiontriangles = 0;
 	for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++)
 	{
 		if (out->num_vertices < 3 || out->num_triangles < 1)
@@ -5023,6 +5047,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 		firstelement = LittleLong(in->firstelement);
 		out->num_firstvertex = meshvertices;
 		out->num_firsttriangle = meshtriangles;
+		out->num_firstcollisiontriangle = collisiontriangles;
 		switch(type)
 		{
 		case Q3FACETYPE_FLAT:
@@ -5089,12 +5114,12 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 
 			out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f);
 
-			if (developer.integer >= 100)
+			if (developer_extra.integer)
 			{
 				if (out->num_triangles < finaltriangles)
-					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
+					Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
 				else
-					Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
+					Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
 			}
 			// q3map does not put in collision brushes for curves... ugh
 			// build the lower quality collision geometry
@@ -5103,26 +5128,40 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
 			finalvertices = finalwidth * finalheight;
 			finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
 
-			out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
-			out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
+			// legacy collision geometry implementation
+			out->deprecatedq3data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
+			out->deprecatedq3data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
 			out->num_collisionvertices = finalvertices;
 			out->num_collisiontriangles = finaltriangles;
-			Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess);
-			Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0);
+			Q3PatchTesselateFloat(3, sizeof(float[3]), out->deprecatedq3data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess);
+			Q3PatchTriangleElements(out->deprecatedq3data_collisionelement3i, finalwidth, finalheight, 0);
 
 			//Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25);
-			Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1);
+			Mod_SnapVertices(3, out->num_collisionvertices, out->deprecatedq3data_collisionvertex3f, 1);
 
 			oldnumtriangles = out->num_triangles;
 			oldnumtriangles2 = out->num_collisiontriangles;
-			out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f);
+			out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_collisionvertex3f);
 
 			// now optimize the collision mesh by finding triangle bboxes...
-			Mod_Q3BSP_BuildBBoxes(out->data_collisionelement3i, out->num_collisiontriangles, out->data_collisionvertex3f, &out->data_collisionbbox6f, &out->num_collisionbboxstride, mod_q3bsp_curves_collisions_stride.integer);
-			Mod_Q3BSP_BuildBBoxes(loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle, out->num_triangles, loadmodel->surfmesh.data_vertex3f, &out->data_bbox6f, &out->num_bboxstride, mod_q3bsp_curves_stride.integer);
+			Mod_Q3BSP_BuildBBoxes(out->deprecatedq3data_collisionelement3i, out->num_collisiontriangles, out->deprecatedq3data_collisionvertex3f, &out->deprecatedq3data_collisionbbox6f, &out->deprecatedq3num_collisionbboxstride, mod_q3bsp_curves_collisions_stride.integer);
+			Mod_Q3BSP_BuildBBoxes(loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle, out->num_triangles, loadmodel->surfmesh.data_vertex3f, &out->deprecatedq3data_bbox6f, &out->deprecatedq3num_bboxstride, mod_q3bsp_curves_stride.integer);
+
+			// store collision geometry for BIH collision tree
+			surfacecollisionvertex3f = loadmodel->brush.data_collisionvertex3f + collisionvertices * 3;
+			surfacecollisionelement3i = loadmodel->brush.data_collisionelement3i + collisiontriangles * 3;
+			Q3PatchTesselateFloat(3, sizeof(float[3]), surfacecollisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess);
+			Q3PatchTriangleElements(surfacecollisionelement3i, finalwidth, finalheight, collisionvertices);
+			Mod_SnapVertices(3, finalvertices, surfacecollisionvertex3f, 1);
+			oldnumtriangles = out->num_triangles;
+			oldnumtriangles2 = out->num_collisiontriangles;
+			out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, surfacecollisionelement3i, surfacecollisionelement3i, loadmodel->brush.data_collisionvertex3f);
+
+			if (developer_extra.integer)
+				Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles);
 
-			if (developer.integer >= 100)
-				Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles);
+			collisionvertices += finalvertices;
+			collisiontriangles += out->num_collisiontriangles;
 			break;
 		default:
 			break;
@@ -5632,6 +5671,365 @@ static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t s
 	}
 }
 
+static void Mod_BIH_TracePoint_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t point)
+{
+	const bih_leaf_t *leaf;
+	const bih_node_t *node;
+	const colbrushf_t *brush;
+	int axis;
+	while (nodenum >= 0)
+	{
+		node = model->collision_bih.nodes + nodenum;
+		axis = node->type - BIH_SPLITX;
+		if (point[axis] <= node->backmax)
+		{
+			if (point[axis] >= node->frontmin)
+				Mod_BIH_TracePoint_RecursiveBIHNode(trace, model, node->front, point);
+			nodenum = node->back;
+		}
+		else if (point[axis] >= node->frontmin)
+			nodenum = node->front;
+		else // no overlap with either child?  just return
+			return;
+	}
+	if (!model->collision_bih.leafs)
+		return;
+	leaf = model->collision_bih.leafs + (-1-nodenum);
+	switch(leaf->type)
+	{
+	case BIH_LEAF:
+		// brush
+		brush = model->brush.data_brushes[leaf->itemindex].colbrushf;
+		Collision_TracePointBrushFloat(trace, point, brush);
+		break;
+	case BIH_LEAF + 1:
+		// triangle - skipped because they have no volume
+		break;
+	default:
+		break;
+	}
+}
+
+static void Mod_BIH_TraceLine_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t start, const vec3_t end, const vec3_t linestart, const vec3_t lineend)
+{
+	const bih_leaf_t *leaf;
+	const bih_node_t *node;
+	const colbrushf_t *brush;
+	const int *e;
+	const texture_t *texture;
+	int axis;
+#if 0
+	int sideflags;
+	vec_t frontdist1;
+	vec_t frontdist2;
+	vec_t frontfrac;
+	vec_t backdist1;
+	vec_t backdist2;
+	vec_t backfrac;
+	vec3_t clipped[2];
+#endif
+	vec3_t segmentmins;
+	vec3_t segmentmaxs;
+	segmentmins[0] = min(start[0], end[0]);
+	segmentmins[1] = min(start[1], end[1]);
+	segmentmins[2] = min(start[2], end[2]);
+	segmentmaxs[0] = max(start[0], end[0]);
+	segmentmaxs[1] = max(start[1], end[1]);
+	segmentmaxs[2] = max(start[2], end[2]);
+	while (nodenum >= 0)
+	{
+		node = model->collision_bih.nodes + nodenum;
+#if 0
+		if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs))
+			return;
+#endif
+		axis = node->type - BIH_SPLITX;
+#if 1
+		if (segmentmins[axis] <= node->backmax)
+		{
+			if (segmentmaxs[axis] >= node->frontmin)
+				Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+			nodenum = node->back;
+		}
+		else if (segmentmaxs[axis] >= node->frontmin)
+			nodenum = node->front;
+		else
+			return; // trace falls between children
+#else
+		frontdist1 = start[axis] - node->backmax;
+		frontdist2 = end[axis] - node->backmax;
+		backdist1 = start[axis] - node->frontmin;
+		backdist2 = end[axis] - node->frontmin;
+		sideflags = 0;
+		if (frontdist1 < 0)
+			sideflags |= 1;
+		if (frontdist2 < 0)
+			sideflags |= 2;
+		if (backdist1 < 0)
+			sideflags |= 4;
+		if (backdist2 < 0)
+			sideflags |= 8;
+		switch(sideflags)
+		{
+		case 0:
+			// start end START END
+			nodenum = node->front;
+			continue;
+		case 1:
+			// START end START END
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[0]);
+			start = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->front;
+			break;
+		case 2:
+			// start END START END
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[0]);
+			end = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->front;
+			break;
+		case 3:
+			// START END START END
+			return; // line falls in gap between children
+		case 4:
+			// start end start END
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			end = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 5:
+			// START end start END
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			end = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 6:
+			// start END start END
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			end = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 7:
+			// START END start END
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			end = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 8:
+			// start end START end
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			start = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 9:
+			// START end START end
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			start = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 10:
+			// start END START end
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend);
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			start = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 11:
+			// START END START end
+			backfrac = backdist1 / (backdist1 - backdist2);
+			VectorLerp(start, backfrac, end, clipped[0]);
+			start = clipped[0];
+			segmentmins[0] = min(start[0], end[0]);
+			segmentmins[1] = min(start[1], end[1]);
+			segmentmins[2] = min(start[2], end[2]);
+			segmentmaxs[0] = max(start[0], end[0]);
+			segmentmaxs[1] = max(start[1], end[1]);
+			segmentmaxs[2] = max(start[2], end[2]);
+			nodenum = node->back;
+			break;
+		case 12:
+			// start end start end
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend);
+			nodenum = node->back;
+			break;
+		case 13:
+			// START end start end
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend);
+			nodenum = node->back;
+			break;
+		case 14:
+			// start END start end
+			frontfrac = frontdist1 / (frontdist1 - frontdist2);
+			VectorLerp(start, frontfrac, end, clipped[1]);
+			Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend);
+			nodenum = node->back;
+			break;
+		case 15:
+			// START END start end
+			nodenum = node->back;
+			continue;
+		}
+#endif
+	}
+	if (!model->collision_bih.leafs)
+		return;
+	leaf = model->collision_bih.leafs + (-1-nodenum);
+#if 1
+	if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs))
+		return;
+#endif
+	switch(leaf->type)
+	{
+	case BIH_LEAF:
+		// brush
+		brush = model->brush.data_brushes[leaf->itemindex].colbrushf;
+		Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
+		break;
+	case BIH_LEAF + 1:
+		// triangle
+		e = model->brush.data_collisionelement3i + 3*leaf->itemindex;
+		texture = model->data_textures + leaf->textureindex;
+		Collision_TraceLineTriangleFloat(trace, linestart, lineend, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture);
+		break;
+	default:
+		break;
+	}
+}
+
+static void Mod_BIH_TraceBrush_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, const vec3_t segmentmins, const vec3_t segmentmaxs)
+{
+	const bih_leaf_t *leaf;
+	const bih_node_t *node;
+	const colbrushf_t *brush;
+	const int *e;
+	const texture_t *texture;
+	int axis;
+	while (nodenum >= 0)
+	{
+		node = model->collision_bih.nodes + nodenum;
+		axis = node->type - BIH_SPLITX;
+#if 0
+#if 0
+		if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs))
+			return;
+#endif
+		Mod_BIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs);
+		nodenum = node->back;
+		continue;
+#endif
+		if (segmentmins[axis] <= node->backmax)
+		{
+			if (segmentmaxs[axis] >= node->frontmin)
+				Mod_BIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs);
+			nodenum = node->back;
+		}
+		else if (segmentmaxs[axis] >= node->frontmin)
+			nodenum = node->front;
+		else
+			return; // trace falls between children
+	}
+	if (!model->collision_bih.leafs)
+		return;
+	leaf = model->collision_bih.leafs + (-1-nodenum);
+#if 1
+	if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs))
+		return;
+#endif
+	switch(leaf->type)
+	{
+	case BIH_LEAF:
+		// brush
+		brush = model->brush.data_brushes[leaf->itemindex].colbrushf;
+		Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush);
+		break;
+	case BIH_LEAF + 1:
+		// triangle
+		e = model->brush.data_collisionelement3i + 3*leaf->itemindex;
+		texture = model->data_textures + leaf->textureindex;
+		Collision_TraceBrushTriangleFloat(trace, thisbrush_start, thisbrush_end, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture);
+		break;
+	default:
+		break;
+	}
+}
+
 static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe)
 {
 	int i;
@@ -5732,10 +6130,10 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *mod
 		for (i = 0;i < leaf->numleafsurfaces;i++)
 		{
 			surface = model->data_surfaces + leaf->firstleafsurface[i];
-			if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
+			if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
 			{
-				surface->collisionmarkframe = markframe;
-				Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
+				surface->deprecatedq3collisionmarkframe = markframe;
+				Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
 			}
 		}
 	}
@@ -5813,10 +6211,10 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo
 		for (i = 0;i < leaf->numleafsurfaces;i++)
 		{
 			surface = model->data_surfaces + leaf->firstleafsurface[i];
-			if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
+			if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
 			{
-				surface->collisionmarkframe = markframe;
-				Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
+				surface->deprecatedq3collisionmarkframe = markframe;
+				Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
 			}
 		}
 	}
@@ -5832,7 +6230,9 @@ static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameble
 	trace->fraction = 1;
 	trace->realfraction = 1;
 	trace->hitsupercontentsmask = hitsupercontentsmask;
-	if (model->brush.submodel)
+	if (mod_collision_bih.integer)
+		Mod_BIH_TracePoint_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start);
+	else if (model->brush.submodel)
 	{
 		for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 			if (brush->colbrushf)
@@ -5865,7 +6265,9 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblen
 	segmentmaxs[0] = max(start[0], end[0]) + 1;
 	segmentmaxs[1] = max(start[1], end[1]) + 1;
 	segmentmaxs[2] = max(start[2], end[2]) + 1;
-	if (model->brush.submodel)
+	if (mod_collision_bih.integer)
+		Mod_BIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end);
+	else if (model->brush.submodel)
 	{
 		for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 			if (brush->colbrushf)
@@ -5873,7 +6275,7 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblen
 		if (mod_q3bsp_curves_collisions.integer)
 			for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
 				if (surface->num_collisiontriangles)
-					Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
+					Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
 	}
 	else
 		Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs);
@@ -5920,7 +6322,9 @@ static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend
 	VectorAdd(end, boxmaxs, boxendmaxs);
 	Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL);
 	Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL);
-	if (model->brush.submodel)
+	if (mod_collision_bih.integer)
+		Mod_BIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, &thisbrush_start.brush, &thisbrush_end.brush, segmentmins, segmentmaxs);
+	else if (model->brush.submodel)
 	{
 		for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 			if (brush->colbrushf)
@@ -5928,7 +6332,7 @@ static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend
 		if (mod_q3bsp_curves_collisions.integer)
 			for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
 				if (surface->num_collisiontriangles)
-					Collision_TraceBrushTriangleMeshFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
+					Collision_TraceBrushTriangleMeshFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
 	}
 	else
 		Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, &thisbrush_start.brush, &thisbrush_end.brush, ++markframe, segmentmins, segmentmaxs);
@@ -5939,8 +6343,14 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const
 	int i;
 	int supercontents = 0;
 	q3mbrush_t *brush;
+	if (mod_collision_bih.integer)
+	{
+		trace_t trace;
+		Mod_Q3BSP_TracePoint(model, NULL, NULL, &trace, point, 0);
+		supercontents = trace.startsupercontents;
+	}
 	// test if the point is inside each brush
-	if (model->brush.submodel)
+	else if (model->brush.submodel)
 	{
 		// submodels are effectively one leaf
 		for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
@@ -5966,6 +6376,88 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const
 	return supercontents;
 }
 
+void Mod_MakeCollisionData(dp_model_t *model)
+{
+	int j;
+	int bihnumleafs;
+	int bihmaxnodes;
+	int brushindex;
+	int triangleindex;
+	int bihleafindex;
+	int nummodelbrushes = model->nummodelbrushes;
+	int nummodelsurfaces = model->nummodelsurfaces;
+	const int *e;
+	const int *collisionelement3i;
+	const float *collisionvertex3f;
+	bih_leaf_t *bihleafs;
+	bih_node_t *bihnodes;
+	int *temp_leafsort;
+	int *temp_leafsortscratch;
+	const msurface_t *surface;
+	const q3mbrush_t *brush;
+
+	// find out how many BIH leaf nodes we need
+	bihnumleafs = model->nummodelbrushes;
+	surface = model->data_surfaces + model->firstmodelsurface;
+	for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++)
+		bihnumleafs += surface->num_collisiontriangles;
+	bihmaxnodes = bihnumleafs - 1;
+
+	// allocate the memory for the BIH leaf nodes
+	bihleafs = Mem_Alloc(loadmodel->mempool, sizeof(bih_leaf_t) * bihnumleafs);
+
+	// add BIH leaf nodes for all the collision brushes
+	bihleafindex = 0;
+	for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++)
+	{
+		bihleafs[bihleafindex].type = BIH_LEAF;
+		bihleafs[bihleafindex].textureindex = brush->texture - model->data_textures;
+		bihleafs[bihleafindex].itemindex = brushindex+model->firstmodelbrush;
+		VectorCopy(brush->colbrushf->mins, bihleafs[bihleafindex].mins);
+		VectorCopy(brush->colbrushf->maxs, bihleafs[bihleafindex].maxs);
+		bihleafindex++;
+	}
+
+	// add BIH leaf nodes for all the collision surfaces
+	collisionelement3i = model->brush.data_collisionelement3i;
+	collisionvertex3f = model->brush.data_collisionvertex3f;
+	for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++)
+	{
+		e = collisionelement3i + 3*surface->num_firstcollisiontriangle;
+		for (triangleindex = 0;triangleindex < surface->num_collisiontriangles;triangleindex++, e += 3)
+		{
+			bihleafs[bihleafindex].type = BIH_LEAF + 1;
+			bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures;
+			bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firstcollisiontriangle;
+			bihleafs[bihleafindex].mins[0] = min(collisionvertex3f[3*e[0]+0], min(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) - 1;
+			bihleafs[bihleafindex].mins[1] = min(collisionvertex3f[3*e[0]+1], min(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) - 1;
+			bihleafs[bihleafindex].mins[2] = min(collisionvertex3f[3*e[0]+2], min(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) - 1;
+			bihleafs[bihleafindex].maxs[0] = max(collisionvertex3f[3*e[0]+0], max(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) + 1;
+			bihleafs[bihleafindex].maxs[1] = max(collisionvertex3f[3*e[0]+1], max(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) + 1;
+			bihleafs[bihleafindex].maxs[2] = max(collisionvertex3f[3*e[0]+2], max(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) + 1;
+			bihleafindex++;
+		}
+	}
+
+	// allocate buffers for the produced and temporary data
+	bihnodes = Mem_Alloc(loadmodel->mempool, sizeof(bih_node_t) * bihmaxnodes);
+	temp_leafsort = Mem_Alloc(loadmodel->mempool, sizeof(int) * bihnumleafs * 2);
+	temp_leafsortscratch = temp_leafsort + bihnumleafs;
+
+	// now build it
+	BIH_Build(&model->collision_bih, bihnumleafs, bihleafs, bihmaxnodes, bihnodes, temp_leafsort, temp_leafsortscratch);
+
+	// we're done with the temporary data
+	Mem_Free(temp_leafsort);
+
+	// resize the BIH nodes array if it over-allocated
+	if (model->collision_bih.maxnodes > model->collision_bih.numnodes)
+	{
+		model->collision_bih.maxnodes = model->collision_bih.numnodes;
+		model->collision_bih.nodes = Mem_Realloc(loadmodel->mempool, model->collision_bih.nodes, model->collision_bih.numnodes * sizeof(bih_node_t));
+	}
+}
+
 static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents)
 {
 	int supercontents = 0;
@@ -6175,7 +6667,8 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 			if (surface->num_triangles > 0)
 				Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
 		loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
-		Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
+		if (loadmodel->brush.shadowmesh)
+			Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
 	}
 
 	loadmodel->brush.num_leafs = 0;
@@ -6277,7 +6770,15 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 				break;
 		if (j < mod->nummodelsurfaces)
 			mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
+
+		Mod_MakeCollisionData(mod);
+
+		// generate VBOs and other shared data before cloning submodels
+		if (i == 0)
+			Mod_BuildVBOs();
 	}
+
+	Con_DPrintf("Stats for q3bsp model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces);
 }
 
 void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
@@ -6296,6 +6797,429 @@ void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend)
 	Host_Error("Mod_MAP_Load: not yet implemented");
 }
 
+#define OBJASMODEL
+
+#ifdef OBJASMODEL
+typedef struct objvertex_s
+{
+	int nextindex;
+	int textureindex;
+	float v[3];
+	float vt[2];
+	float vn[3];
+}
+objvertex_t;
+
+void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+	const char *textbase = (char *)buffer, *text = textbase;
+	char *s;
+	char *argv[512];
+	char line[1024];
+	char materialname[MAX_QPATH];
+	int i, j, numvertices, firstvertex, firsttriangle, elementindex, vertexindex, numsurfaces, surfacevertices, surfacetriangles, surfaceelements;
+	int index1, index2, index3;
+	objvertex_t vfirst, vprev, vcurrent;
+	int argc;
+	int linelen;
+	int numtriangles = 0;
+	int maxtriangles = 0;
+	objvertex_t *vertices = NULL;
+	int linenumber = 0;
+	int maxtextures = 0, numtextures = 0, textureindex = 0;
+	int maxv = 0, numv = 1;
+	int maxvt = 0, numvt = 1;
+	int maxvn = 0, numvn = 1;
+	char *texturenames = NULL;
+	float dist, modelradius, modelyawradius;
+	float *v = NULL;
+	float *vt = NULL;
+	float *vn = NULL;
+	float mins[3];
+	float maxs[3];
+	objvertex_t *thisvertex = NULL;
+	int vertexhashindex;
+	int *vertexhashtable = NULL;
+	objvertex_t *vertexhashdata = NULL;
+	objvertex_t *vdata = NULL;
+	int vertexhashsize = 0;
+	int vertexhashcount = 0;
+	skinfile_t *skinfiles = NULL;
+	unsigned char *data = NULL;
+
+	memset(&vfirst, 0, sizeof(vfirst));
+	memset(&vprev, 0, sizeof(vprev));
+	memset(&vcurrent, 0, sizeof(vcurrent));
+
+	dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name);
+
+	loadmodel->modeldatatypestring = "OBJ";
+
+	loadmodel->type = mod_obj;
+	loadmodel->soundfromcenter = true;
+	loadmodel->TraceBox = NULL;
+	loadmodel->TraceLine = NULL;
+	loadmodel->TracePoint = NULL;
+	loadmodel->PointSuperContents = NULL;
+	loadmodel->brush.TraceLineOfSight = NULL;
+	loadmodel->brush.SuperContentsFromNativeContents = NULL;
+	loadmodel->brush.NativeContentsFromSuperContents = NULL;
+	loadmodel->brush.GetPVS = NULL;
+	loadmodel->brush.FatPVS = NULL;
+	loadmodel->brush.BoxTouchingPVS = NULL;
+	loadmodel->brush.BoxTouchingLeafPVS = NULL;
+	loadmodel->brush.BoxTouchingVisibleLeafs = NULL;
+	loadmodel->brush.FindBoxClusters = NULL;
+	loadmodel->brush.LightPoint = NULL;
+	loadmodel->brush.FindNonSolidLocation = NULL;
+	loadmodel->brush.AmbientSoundLevelsForPoint = NULL;
+	loadmodel->brush.RoundUpToHullSize = NULL;
+	loadmodel->brush.PointInLeaf = NULL;
+	loadmodel->Draw = R_Q1BSP_Draw;
+	loadmodel->DrawDepth = R_Q1BSP_DrawDepth;
+	loadmodel->DrawDebug = R_Q1BSP_DrawDebug;
+	loadmodel->DrawPrepass = R_Q1BSP_DrawPrepass;
+	loadmodel->GetLightInfo = R_Q1BSP_GetLightInfo;
+	loadmodel->CompileShadowMap = R_Q1BSP_CompileShadowMap;
+	loadmodel->DrawShadowMap = R_Q1BSP_DrawShadowMap;
+	loadmodel->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+	loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+	loadmodel->DrawLight = R_Q1BSP_DrawLight;
+
+	skinfiles = Mod_LoadSkinFiles();
+	if (loadmodel->numskins < 1)
+		loadmodel->numskins = 1;
+
+	// make skinscenes for the skins (no groups)
+	loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
+	for (i = 0;i < loadmodel->numskins;i++)
+	{
+		loadmodel->skinscenes[i].firstframe = i;
+		loadmodel->skinscenes[i].framecount = 1;
+		loadmodel->skinscenes[i].loop = true;
+		loadmodel->skinscenes[i].framerate = 10;
+	}
+
+	VectorClear(mins);
+	VectorClear(maxs);
+
+	// parse the OBJ text now
+	for(;;)
+	{
+		if (!*text)
+			break;
+		linenumber++;
+		linelen = 0;
+		for (linelen = 0;text[linelen] && text[linelen] != '\r' && text[linelen] != '\n';linelen++)
+			line[linelen] = text[linelen];
+		line[linelen] = 0;
+		for (argc = 0;argc < 4;argc++)
+			argv[argc] = "";
+		argc = 0;
+		s = line;
+		while (*s == ' ' || *s == '\t')
+			s++;
+		while (*s)
+		{
+			argv[argc++] = s;
+			while (*s > ' ')
+				s++;
+			if (!*s)
+				break;
+			*s++ = 0;
+			while (*s == ' ' || *s == '\t')
+				s++;
+		}
+		text += linelen;
+		if (*text == '\r')
+			text++;
+		if (*text == '\n')
+			text++;
+		if (!argc)
+			continue;
+		if (argv[0][0] == '#')
+			continue;
+		if (!strcmp(argv[0], "v"))
+		{
+			if (maxv <= numv)
+			{
+				maxv = max(maxv * 2, 1024);
+				v = (float *)Mem_Realloc(tempmempool, v, maxv * sizeof(float[3]));
+			}
+			v[numv*3+0] = atof(argv[1]);
+			v[numv*3+2] = atof(argv[2]);
+			v[numv*3+1] = atof(argv[3]);
+			numv++;
+		}
+		else if (!strcmp(argv[0], "vt"))
+		{
+			if (maxvt <= numvt)
+			{
+				maxvt = max(maxvt * 2, 1024);
+				vt = (float *)Mem_Realloc(tempmempool, vt, maxvt * sizeof(float[2]));
+			}
+			vt[numvt*2+0] = atof(argv[1]);
+			vt[numvt*2+1] = 1-atof(argv[2]);
+			numvt++;
+		}
+		else if (!strcmp(argv[0], "vn"))
+		{
+			if (maxvn <= numvn)
+			{
+				maxvn = max(maxvn * 2, 1024);
+				vn = (float *)Mem_Realloc(tempmempool, vn, maxvn * sizeof(float[3]));
+			}
+			vn[numvn*3+0] = atof(argv[1]);
+			vn[numvn*3+2] = atof(argv[2]);
+			vn[numvn*3+1] = atof(argv[3]);
+			numvn++;
+		}
+		else if (!strcmp(argv[0], "f"))
+		{
+			if (!numtextures)
+			{
+				if (maxtextures <= numtextures)
+				{
+					maxtextures = max(maxtextures * 2, 256);
+					texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH);
+				}
+				textureindex = numtextures++;
+				strlcpy(texturenames + textureindex*MAX_QPATH, loadmodel->name, MAX_QPATH);
+			}
+			for (j = 1;j < argc;j++)
+			{
+				index1 = atoi(argv[j]);
+				while(argv[j][0] && argv[j][0] != '/')
+					argv[j]++;
+				if (argv[j][0])
+					argv[j]++;
+				index2 = atoi(argv[j]);
+				while(argv[j][0] && argv[j][0] != '/')
+					argv[j]++;
+				if (argv[j][0])
+					argv[j]++;
+				index3 = atoi(argv[j]);
+				// negative refers to a recent vertex
+				// zero means not specified
+				// positive means an absolute vertex index
+				if (index1 < 0)
+					index1 = numv - index1;
+				if (index2 < 0)
+					index2 = numvt - index2;
+				if (index3 < 0)
+					index3 = numvn - index3;
+				vcurrent.nextindex = -1;
+				vcurrent.textureindex = textureindex;
+				VectorCopy(v + 3*index1, vcurrent.v);
+				Vector2Copy(vt + 2*index2, vcurrent.vt);
+				VectorCopy(vn + 3*index3, vcurrent.vn);
+				if (numtriangles == 0)
+				{
+					VectorCopy(vcurrent.v, mins);
+					VectorCopy(vcurrent.v, maxs);
+				}
+				else
+				{
+					mins[0] = min(mins[0], vcurrent.v[0]);
+					mins[1] = min(mins[1], vcurrent.v[1]);
+					mins[2] = min(mins[2], vcurrent.v[2]);
+					maxs[0] = max(maxs[0], vcurrent.v[0]);
+					maxs[1] = max(maxs[1], vcurrent.v[1]);
+					maxs[2] = max(maxs[2], vcurrent.v[2]);
+				}
+				if (j == 1)
+					vfirst = vcurrent;
+				else if (j >= 3)
+				{
+					if (maxtriangles <= numtriangles)
+					{
+						maxtriangles = max(maxtriangles * 2, 32768);
+						vertices = (objvertex_t*)Mem_Realloc(loadmodel->mempool, vertices, maxtriangles * sizeof(objvertex_t[3]));
+					}
+					vertices[numtriangles*3+0] = vfirst;
+					vertices[numtriangles*3+1] = vprev;
+					vertices[numtriangles*3+2] = vcurrent;
+					numtriangles++;
+				}
+				vprev = vcurrent;
+			}
+		}
+		else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g"))
+			;
+		else if (!strcmp(argv[0], "usemtl"))
+		{
+			for (i = 0;i < numtextures;i++)
+				if (!strcmp(texturenames+i*MAX_QPATH, argv[1]))
+					break;
+			if (i < numtextures)
+				textureindex = i;
+			else
+			{
+				if (maxtextures <= numtextures)
+				{
+					maxtextures = max(maxtextures * 2, 256);
+					texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH);
+				}
+				textureindex = numtextures++;
+				strlcpy(texturenames + textureindex*MAX_QPATH, argv[1], MAX_QPATH);
+			}
+		}
+	}
+
+	// now that we have the OBJ data loaded as-is, we can convert it
+
+	// copy the model bounds, then enlarge the yaw and rotated bounds according to radius
+	VectorCopy(mins, loadmodel->normalmins);
+	VectorCopy(maxs, loadmodel->normalmaxs);
+	dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0]));
+	modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1]));
+	modelyawradius = dist*dist+modelyawradius*modelyawradius;
+	modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2]));
+	modelradius = modelyawradius + modelradius * modelradius;
+	modelyawradius = sqrt(modelyawradius);
+	modelradius = sqrt(modelradius);
+	loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius;
+	loadmodel->yawmins[2] = loadmodel->normalmins[2];
+	loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] =  modelyawradius;
+	loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
+	loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius;
+	loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] =  modelradius;
+	loadmodel->radius = modelradius;
+	loadmodel->radius2 = modelradius * modelradius;
+
+	// allocate storage for triangles
+	loadmodel->num_surfaces = loadmodel->nummodelsurfaces = numsurfaces = numtextures;
+	loadmodel->surfmesh.data_element3i = Mem_Alloc(loadmodel->mempool, numtriangles * sizeof(int[3]));
+	loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t));
+	// allocate vertex hash structures to build an optimal vertex subset
+	vertexhashsize = numtriangles*2;
+	vertexhashtable = Mem_Alloc(loadmodel->mempool, sizeof(int) * vertexhashsize);
+	memset(vertexhashtable, 0xFF, sizeof(int) * vertexhashsize);
+	vertexhashdata = Mem_Alloc(loadmodel->mempool, sizeof(*vertexhashdata) * numtriangles*3);
+	vertexhashcount = 0;
+
+	// gather surface stats for assigning vertex/triangle ranges
+	firstvertex = 0;
+	firsttriangle = 0;
+	elementindex = 0;
+	for (textureindex = 0;textureindex < numtextures;textureindex++)
+	{
+		msurface_t *surface = loadmodel->data_surfaces + textureindex;
+		// copy the mins/maxs of the model backwards so that the first vertex
+		// added will set the surface bounds to a point
+		VectorCopy(loadmodel->normalmaxs, surface->mins);
+		VectorCopy(loadmodel->normalmins, surface->maxs);
+		surfacevertices = 0;
+		surfaceelements = 0;
+		for (vertexindex = 0;vertexindex < numtriangles*3;vertexindex++)
+		{
+			thisvertex = vertices + vertexindex;
+			if (thisvertex->textureindex != textureindex)
+				continue;
+			surface->mins[0] = min(surface->mins[0], thisvertex->v[0]);
+			surface->mins[1] = min(surface->mins[1], thisvertex->v[1]);
+			surface->mins[2] = min(surface->mins[2], thisvertex->v[2]);
+			surface->maxs[0] = max(surface->maxs[0], thisvertex->v[0]);
+			surface->maxs[1] = max(surface->maxs[1], thisvertex->v[1]);
+			surface->maxs[2] = max(surface->maxs[2], thisvertex->v[2]);
+			vertexhashindex = (unsigned int)(thisvertex->v[0] * 3571 + thisvertex->v[0] * 1777 + thisvertex->v[0] * 457) % (unsigned int)vertexhashsize;
+			for (i = vertexhashtable[vertexhashindex];i >= 0;i = vertexhashdata[i].nextindex)
+			{
+				vdata = vertexhashdata + i;
+				if (vdata->textureindex == thisvertex->textureindex && VectorCompare(thisvertex->v, vdata->v) && VectorCompare(thisvertex->vn, vdata->vn) && Vector2Compare(thisvertex->vt, vdata->vt))
+					break;
+			}
+			if (i < 0)
+			{
+				i = vertexhashcount++;
+				vdata = vertexhashdata + i;
+				*vdata = *thisvertex;
+				vdata->nextindex = vertexhashtable[vertexhashindex];
+				vertexhashtable[vertexhashindex] = i;
+				surfacevertices++;
+			}
+			loadmodel->surfmesh.data_element3i[elementindex++] = i;
+			surfaceelements++;
+		}
+		surfacetriangles = surfaceelements / 3;
+		surface->num_vertices = surfacevertices;
+		surface->num_triangles = surfacetriangles;
+		surface->num_firstvertex = firstvertex;
+		surface->num_firsttriangle = firsttriangle;
+		firstvertex += surface->num_vertices;
+		firsttriangle += surface->num_triangles;
+	}
+	numvertices = firstvertex;
+
+	// allocate storage for final mesh data
+	loadmodel->num_textures = numtextures * loadmodel->numskins;
+	loadmodel->num_texturesperskin = numtextures;
+	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, numsurfaces * sizeof(int) + numsurfaces * loadmodel->numskins * sizeof(texture_t) + numtriangles * sizeof(int[3]) + (numvertices <= 65536 ? numtriangles * sizeof(unsigned short[3]) : 0) + numvertices * sizeof(float[14]));
+	loadmodel->sortedmodelsurfaces = (int *)data;data += numsurfaces * sizeof(int);
+	loadmodel->data_textures = (texture_t *)data;data += numsurfaces * loadmodel->numskins * sizeof(texture_t);
+	loadmodel->surfmesh.num_vertices = numvertices;
+	loadmodel->surfmesh.num_triangles = numtriangles;
+	loadmodel->surfmesh.data_neighbor3i = (int *)data;data += numtriangles * sizeof(int[3]);
+	loadmodel->surfmesh.data_vertex3f = (float *)data;data += numvertices * sizeof(float[3]);
+	loadmodel->surfmesh.data_svector3f = (float *)data;data += numvertices * sizeof(float[3]);
+	loadmodel->surfmesh.data_tvector3f = (float *)data;data += numvertices * sizeof(float[3]);
+	loadmodel->surfmesh.data_normal3f = (float *)data;data += numvertices * sizeof(float[3]);
+	loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += numvertices * sizeof(float[2]);
+	if (loadmodel->surfmesh.num_vertices <= 65536)
+		loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
+
+	for (j = 0;j < loadmodel->surfmesh.num_vertices;j++)
+	{
+		VectorCopy(vertexhashdata[j].v, loadmodel->surfmesh.data_vertex3f + 3*j);
+		VectorCopy(vertexhashdata[j].vn, loadmodel->surfmesh.data_normal3f + 3*j);
+		Vector2Copy(vertexhashdata[j].vt, loadmodel->surfmesh.data_texcoordtexture2f + 2*j);
+	}
+
+	// load the textures
+	for (textureindex = 0;textureindex < numtextures;textureindex++)
+		Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + textureindex, skinfiles, texturenames + textureindex*MAX_QPATH, texturenames + textureindex*MAX_QPATH);
+	Mod_FreeSkinFiles(skinfiles);
+
+	// set the surface textures
+	for (textureindex = 0;textureindex < numtextures;textureindex++)
+	{
+		msurface_t *surface = loadmodel->data_surfaces + textureindex;
+		surface->texture = loadmodel->data_textures + textureindex;
+	}
+
+	// free data
+	Mem_Free(vertices);
+	Mem_Free(texturenames);
+	Mem_Free(v);
+	Mem_Free(vt);
+	Mem_Free(vn);
+	Mem_Free(vertexhashtable);
+	Mem_Free(vertexhashdata);
+
+	// compute all the mesh information that was not loaded from the file
+	Mod_MakeSortedSurfaces(loadmodel);
+	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];
+	Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
+	// generate normals if the file did not have them
+	if (!VectorLength2(loadmodel->surfmesh.data_normal3f))
+		Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true);
+	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);
+	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+}
+
+
+
+
+
+
+
+
+
+
+#else // OBJASMODEL
+
 #ifdef OBJWORKS
 typedef struct objvertex_s
 {
@@ -6917,10 +7841,10 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
 					{
 						objtriangle_t *oldtriangles = triangles;
 						maxtriangles *= 2;
-						triangles = Mem_Alloc(tempmempool, numtriangles * sizeof(*triangles));
+						triangles = Mem_Alloc(tempmempool, maxtriangles * sizeof(*triangles));
 						if (oldtriangles)
 						{
-							memcpy(triangles, oldtriangles, numtriangles * sizeof(*triangles));
+							memcpy(triangles, oldtriangles, maxtriangles * sizeof(*triangles));
 							Mem_Free(oldtriangles);
 						}
 					}
@@ -6952,7 +7876,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
 					textures = Mem_Alloc(tempmempool, maxtextures * sizeof(*textures));
 					if (oldtextures)
 					{
-						memcpy(textures, oldtextures, numtexutres * sizeof(*textures));
+						memcpy(textures, oldtextures, numtextures * sizeof(*textures));
 						Mem_Free(oldtextures);
 					}
 				}
@@ -6974,7 +7898,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
 	loadmodel->num_textures = numtextures;
 	loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
 	for (i = 0;i < numtextures;i++)
-		Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
+		Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
 
 	// free the texturenames array since we are now done with it
 	for (i = 0;i < numtextures;i++)
@@ -7078,7 +8002,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
 		loadmodel->num_texturesperskin = loadmodel->num_surfaces;
 		loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
 		for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
-			Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP | TEXF_COMPRESS);
+			Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS);
 	}
 	else
 	{
@@ -7216,6 +8140,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
 			loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
 #endif
 }
+#endif // !OBJASMODEL
 
 qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
 {