tf2/tf2_src/engine/cmodel_bsp.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "tier0/platform.h"
#include "sysexternal.h"
#include "cmodel_engine.h"
#include "dispcoll_common.h"
#include "modelloader.h"
#include "common.h"
#include "zone.h"

// UNDONE: Abstract the texture/material lookup stuff and all of this goes away
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "materialsystem/materialsystem_config.h"
extern IMaterialSystem *materials;

#include "vphysics_interface.h"
#include "sys_dll.h"
#include "tier2/tier2.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

extern int g_iServerGameDLLVersion;
IPhysicsSurfaceProps *physprop = NULL;
IPhysicsCollision	 *physcollision = NULL;

// local forward declarations
void CollisionBSPData_LoadTextures( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadTexinfo( CCollisionBSPData *pBSPData, CUtlVector<unsigned short> &map_texinfo );
void CollisionBSPData_LoadLeafs_Version_0( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadLeafs_Version_1( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadLeafs( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadLeafBrushes( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadPlanes( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadBrushes( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadBrushSides( CCollisionBSPData *pBSPData, CUtlVector<unsigned short> &map_texinfo );
void CollisionBSPData_LoadSubmodels( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadNodes( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadAreas( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadAreaPortals( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadVisibility( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadEntityString( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadPhysics( CCollisionBSPData *pBSPData );
void CollisionBSPData_LoadDispInfo( CCollisionBSPData *pBSPData );


//=============================================================================
//
// Initialization/Destruction Functions
//


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CollisionBSPData_Init( CCollisionBSPData *pBSPData )
{
	pBSPData->numleafs = 1;
	pBSPData->map_vis = NULL;
	pBSPData->numareas = 1;
	pBSPData->numclusters = 1;
	pBSPData->map_nullname = "**empty**";
	pBSPData->numtextures = 0;

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_Destroy( CCollisionBSPData *pBSPData )
{
	for ( int i = 0; i < pBSPData->numcmodels; i++ )
	{
		physcollision->VCollideUnload( &pBSPData->map_cmodels[i].vcollisionData );
	}

	// free displacement data
	DispCollTrees_FreeLeafList( pBSPData );
	CM_DestroyDispPhysCollide();
	DispCollTrees_Free( g_pDispCollTrees );
	g_pDispCollTrees = NULL;
	g_pDispBounds = NULL;
	g_DispCollTreeCount = 0;

	if ( pBSPData->map_planes.Base() )
	{
		pBSPData->map_planes.Detach();
	}

	if ( pBSPData->map_texturenames )
	{
		pBSPData->map_texturenames = NULL;
	}

	if ( pBSPData->map_surfaces.Base() )
	{
		pBSPData->map_surfaces.Detach();
	}

	if ( pBSPData->map_areaportals.Base() )
	{
		pBSPData->map_areaportals.Detach();
	}

	if ( pBSPData->portalopen.Base() )
	{
		pBSPData->portalopen.Detach();
	}

	if ( pBSPData->map_areas.Base() )
	{
		pBSPData->map_areas.Detach();
	}

	pBSPData->map_entitystring.Discard();

	if ( pBSPData->map_brushes.Base() )
	{
		pBSPData->map_brushes.Detach();
	}

	if ( pBSPData->map_dispList.Base() )
	{
		pBSPData->map_dispList.Detach();
	}

	if ( pBSPData->map_cmodels.Base() )
	{
		pBSPData->map_cmodels.Detach();
	}

	if ( pBSPData->map_leafbrushes.Base() )
	{
		pBSPData->map_leafbrushes.Detach();
	}

	if ( pBSPData->map_leafs.Base() )
	{
		pBSPData->map_leafs.Detach();
	}

	if ( pBSPData->map_nodes.Base() )
	{
		pBSPData->map_nodes.Detach();
	}

	if ( pBSPData->map_brushsides.Base() )
	{
		pBSPData->map_brushsides.Detach();
	}

	if ( pBSPData->map_vis )
	{
		pBSPData->map_vis = NULL;
	}

	pBSPData->numplanes = 0;
	pBSPData->numbrushsides = 0;
	pBSPData->emptyleaf = pBSPData->solidleaf =0;
	pBSPData->numnodes = 0;
	pBSPData->numleafs = 0;
	pBSPData->numbrushes = 0;
	pBSPData->numdisplist = 0;
	pBSPData->numleafbrushes = 0;
	pBSPData->numareas = 0;
	pBSPData->numtextures = 0;
	pBSPData->floodvalid = 0;
	pBSPData->numareaportals = 0;
	pBSPData->numclusters = 0;
	pBSPData->numcmodels = 0;
	pBSPData->numvisibility = 0;
	pBSPData->numentitychars = 0;
	pBSPData->numportalopen = 0;
	pBSPData->map_name[0] = 0;
	pBSPData->map_rootnode = NULL;
}

//-----------------------------------------------------------------------------
// Returns the collision tree associated with the ith displacement
//-----------------------------------------------------------------------------

CDispCollTree* CollisionBSPData_GetCollisionTree( int i )
{
	if ((i < 0) || (i >= g_DispCollTreeCount))
		return 0;

	return &g_pDispCollTrees[i];
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LinkPhysics( void )
{
	//
	// initialize the physics surface properties -- if necessary!
	//
	if( !physprop )
	{
		physprop = ( IPhysicsSurfaceProps* )g_AppSystemFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL );
		physcollision = ( IPhysicsCollision* )g_AppSystemFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL );

		if ( !physprop || !physcollision )
		{
			Sys_Error( "CollisionBSPData_PreLoad: Can't link physics" );
		}
	}
}


//=============================================================================
//
// Loading Functions
//

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_PreLoad( CCollisionBSPData *pBSPData )
{
	// initialize the collision bsp data
	CollisionBSPData_Init( pBSPData ); 
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CollisionBSPData_Load( const char *pName, CCollisionBSPData *pBSPData )
{
	// This is a table that maps texinfo references to csurface_t
	// It is freed after the map has been loaded
	CUtlVector<unsigned short> 	map_texinfo;

	// copy map name
	Q_strncpy( pBSPData->map_name, pName, sizeof( pBSPData->map_name ) );

	//
	// load bsp file data
	//
	COM_TimestampedLog( "  CollisionBSPData_LoadTextures" );
	CollisionBSPData_LoadTextures( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadTexinfo" );
	CollisionBSPData_LoadTexinfo( pBSPData, map_texinfo );

	COM_TimestampedLog( "  CollisionBSPData_LoadLeafs" );
	CollisionBSPData_LoadLeafs( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadLeafBrushes" );
	CollisionBSPData_LoadLeafBrushes( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadPlanes" );
	CollisionBSPData_LoadPlanes( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadBrushes" );
	CollisionBSPData_LoadBrushes( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadBrushSides" );
	CollisionBSPData_LoadBrushSides( pBSPData, map_texinfo );

	COM_TimestampedLog( "  CollisionBSPData_LoadSubmodels" );
	CollisionBSPData_LoadSubmodels( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadPlanes" );
	CollisionBSPData_LoadNodes( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadAreas" );
	CollisionBSPData_LoadAreas( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadAreaPortals" );
	CollisionBSPData_LoadAreaPortals( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadVisibility" );
	CollisionBSPData_LoadVisibility( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadEntityString" );
	CollisionBSPData_LoadEntityString( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadPhysics" );
	CollisionBSPData_LoadPhysics( pBSPData );

	COM_TimestampedLog( "  CollisionBSPData_LoadDispInfo" );
    CollisionBSPData_LoadDispInfo( pBSPData );

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadTextures( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_TEXDATA );

	CMapLoadHelper lhStringData( LUMP_TEXDATA_STRING_DATA );
	const char *pStringData = ( const char * )lhStringData.LumpBase();

	CMapLoadHelper lhStringTable( LUMP_TEXDATA_STRING_TABLE );
	if( lhStringTable.LumpSize() % sizeof( int ) )
		Sys_Error( "CMod_LoadTextures: funny lump size");
	int *pStringTable = ( int * )lhStringTable.LumpBase();

	dtexdata_t	*in;
	int			i, count;
	IMaterial	*material;

	in = (dtexdata_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadTextures: funny lump size");
	}
	count = lh.LumpSize() / sizeof(*in);
	if (count < 1)
	{
		Sys_Error( "Map with no textures");
	}
	if (count > MAX_MAP_TEXDATA)
	{
		Sys_Error( "Map has too many textures");
	}

	int nSize = count * sizeof(csurface_t);
	pBSPData->map_surfaces.Attach( count, (csurface_t*)Hunk_Alloc( nSize ) );

	pBSPData->numtextures = count;

	pBSPData->map_texturenames = (char *)Hunk_Alloc( lhStringData.LumpSize() * sizeof(char), false );
	memcpy( pBSPData->map_texturenames, pStringData, lhStringData.LumpSize() );
 
	for ( i=0 ; i<count ; i++, in++ )
	{
		Assert( in->nameStringTableID >= 0 );
		Assert( pStringTable[in->nameStringTableID] >= 0 );

		const char *pInName = &pStringData[pStringTable[in->nameStringTableID]];
		int index = pInName - pStringData;
		
		csurface_t *out = &pBSPData->map_surfaces[i];
		out->name = &pBSPData->map_texturenames[index];
		out->surfaceProps = 0;
		out->flags = 0;

		material = materials->FindMaterial( pBSPData->map_surfaces[i].name, TEXTURE_GROUP_WORLD, true );
		if ( !IsErrorMaterial( material ) )
		{
			IMaterialVar *var;
			bool varFound;
			var = material->FindVar( "$surfaceprop", &varFound, false );
			if ( varFound )
			{
				const char *pProps = var->GetStringValue();
				pBSPData->map_surfaces[i].surfaceProps = physprop->GetSurfaceIndex( pProps );
			}
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadTexinfo( CCollisionBSPData *pBSPData, 
									CUtlVector<unsigned short> &map_texinfo )
{
	CMapLoadHelper lh( LUMP_TEXINFO );

	texinfo_t	*in;
	unsigned short	out;
	int			i, count;

	in = (texinfo_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
		Sys_Error( "CollisionBSPData_LoadTexinfo: funny lump size");
	count = lh.LumpSize() / sizeof(*in);
	if (count < 1)
		Sys_Error( "Map with no texinfo");
	if (count > MAX_MAP_TEXINFO)
		Sys_Error( "Map has too many surfaces");

	MEM_ALLOC_CREDIT();
	map_texinfo.RemoveAll();
	map_texinfo.EnsureCapacity( count );

	for ( i=0 ; i<count ; i++, in++ )
	{
		out = in->texdata;
		
		if ( out >= pBSPData->numtextures )
			out = 0;

		// HACKHACK: Copy this over for the whole material!!!
		pBSPData->map_surfaces[out].flags |= in->flags;
		map_texinfo.AddToTail(out);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadLeafs_Version_0( CCollisionBSPData *pBSPData, CMapLoadHelper &lh )
{
	int			i;
	dleaf_version_0_t 	*in;
	int			count;
	
	in = (dleaf_version_0_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CollisionBSPData_LoadLeafs: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);

	if (count < 1)
	{
		Sys_Error( "Map with no leafs");
	}

	// need to save space for box planes
	if (count > MAX_MAP_PLANES)
	{
		Sys_Error( "Map has too many planes");
	}

	// Need an extra one for the emptyleaf below
	int nSize = (count + 1) * sizeof(cleaf_t);
	pBSPData->map_leafs.Attach( count + 1, (cleaf_t*)Hunk_Alloc( nSize ) );

	pBSPData->numleafs = count;
	pBSPData->numclusters = 0;

	for ( i=0 ; i<count ; i++, in++ )
	{
		cleaf_t	*out = &pBSPData->map_leafs[i];	
		out->contents = in->contents;
		out->cluster = in->cluster;
		out->area = in->area;
		out->flags = in->flags;
		out->firstleafbrush = in->firstleafbrush;
		out->numleafbrushes = in->numleafbrushes;

		out->dispCount = 0;

		if (out->cluster >= pBSPData->numclusters)
		{
			pBSPData->numclusters = out->cluster + 1;
		}
	}

	if (pBSPData->map_leafs[0].contents != CONTENTS_SOLID)
	{
		Sys_Error( "Map leaf 0 is not CONTENTS_SOLID");
	}

	pBSPData->solidleaf = 0;
	pBSPData->emptyleaf = pBSPData->numleafs;
	memset( &pBSPData->map_leafs[pBSPData->emptyleaf], 0, sizeof(pBSPData->map_leafs[pBSPData->emptyleaf]) );
	pBSPData->numleafs++;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadLeafs_Version_1( CCollisionBSPData *pBSPData, CMapLoadHelper &lh )
{
	int			i;
	dleaf_t 	*in;
	int			count;
	
	in = (dleaf_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CollisionBSPData_LoadLeafs: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);

	if (count < 1)
	{
		Sys_Error( "Map with no leafs");
	}

	// need to save space for box planes
	if (count > MAX_MAP_PLANES)
	{
		Sys_Error( "Map has too many planes");
	}

	// Need an extra one for the emptyleaf below
	int nSize = (count + 1) * sizeof(cleaf_t);
	pBSPData->map_leafs.Attach( count + 1, (cleaf_t*)Hunk_Alloc( nSize ) );

	pBSPData->numleafs = count;
	pBSPData->numclusters = 0;

	for ( i=0 ; i<count ; i++, in++ )
	{
		cleaf_t	*out = &pBSPData->map_leafs[i];	
		out->contents = in->contents;
		out->cluster = in->cluster;
		out->area = in->area;
		out->flags = in->flags;
		out->firstleafbrush = in->firstleafbrush;
		out->numleafbrushes = in->numleafbrushes;

		out->dispCount = 0;

		if (out->cluster >= pBSPData->numclusters)
		{
			pBSPData->numclusters = out->cluster + 1;
		}
	}

	if (pBSPData->map_leafs[0].contents != CONTENTS_SOLID)
	{
		Sys_Error( "Map leaf 0 is not CONTENTS_SOLID");
	}

	pBSPData->solidleaf = 0;
	pBSPData->emptyleaf = pBSPData->numleafs;
	memset( &pBSPData->map_leafs[pBSPData->emptyleaf], 0, sizeof(pBSPData->map_leafs[pBSPData->emptyleaf]) );
	pBSPData->numleafs++;
}

void CollisionBSPData_LoadLeafs( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_LEAFS );
	switch( lh.LumpVersion() )
	{
	case 0:
		CollisionBSPData_LoadLeafs_Version_0( pBSPData, lh );
		break;
	case 1:
		CollisionBSPData_LoadLeafs_Version_1( pBSPData, lh );
		break;
	default:
		Assert( 0 );
		Error( "Unknown LUMP_LEAFS version\n" );
		break;
	}

}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadLeafBrushes( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_LEAFBRUSHES );

	int			i;
	unsigned short 	*in;
	int			count;
	
	in = (unsigned short *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadLeafBrushes: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);
	if (count < 1)
	{
		Sys_Error( "Map with no planes");
	}

	// need to save space for box planes
	if (count > MAX_MAP_LEAFBRUSHES)
	{
		Sys_Error( "Map has too many leafbrushes");
	}

	pBSPData->map_leafbrushes.Attach( count, (unsigned short*)Hunk_Alloc( count * sizeof(unsigned short), false ) );
	pBSPData->numleafbrushes = count;

	for ( i=0 ; i<count ; i++, in++)
	{
		pBSPData->map_leafbrushes[i] = *in;
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadPlanes( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_PLANES );

	int			i, j;
	dplane_t 	*in;
	int			count;
	int			bits;
	
	in = (dplane_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CollisionBSPData_LoadPlanes: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);

	if (count < 1)
	{
		Sys_Error( "Map with no planes");
	}

	// need to save space for box planes
	if (count > MAX_MAP_PLANES)
	{
		Sys_Error( "Map has too many planes");
	}

	int nSize = count * sizeof(cplane_t);
	pBSPData->map_planes.Attach( count, (cplane_t*)Hunk_Alloc( nSize ) );

	pBSPData->numplanes = count;

	for ( i=0 ; i<count ; i++, in++)
	{
		cplane_t *out = &pBSPData->map_planes[i];	
		bits = 0;
		for (j=0 ; j<3 ; j++)
		{
			out->normal[j] = in->normal[j];
			if (out->normal[j] < 0)
			{
				bits |= 1<<j;
			}
		}

		out->dist = in->dist;
		out->type = in->type;
		out->signbits = bits;
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadBrushes( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_BRUSHES );

	dbrush_t	*in;
	int			i, count;
	
	in = (dbrush_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadBrushes: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);
	if (count > MAX_MAP_BRUSHES)
	{
		Sys_Error( "Map has too many brushes");
	}

	int nSize = count * sizeof(cbrush_t);
	pBSPData->map_brushes.Attach( count, (cbrush_t*)Hunk_Alloc( nSize ) );

	pBSPData->numbrushes = count;

	for (i=0 ; i<count ; i++, in++)
	{
		cbrush_t *out = &pBSPData->map_brushes[i];
		out->firstbrushside = in->firstside;
		out->numsides = in->numsides;
		out->contents = in->contents;
	}
}

inline bool IsBoxBrush( const cbrush_t &brush, dbrushside_t *pSides, cplane_t *pPlanes )
{
	int countAxial = 0;
	if ( brush.numsides == 6 )
	{
		for ( int i = 0; i < brush.numsides; i++ )
		{
			cplane_t *plane = pPlanes + pSides[brush.firstbrushside+i].planenum;
			if ( plane->type > PLANE_Z )
				break;
			countAxial++;
		}
	}
	return (countAxial == brush.numsides) ? true : false;
}

inline void ExtractBoxBrush( cboxbrush_t *pBox, const cbrush_t &brush, dbrushside_t *pSides, cplane_t *pPlanes, CUtlVector<unsigned short> &map_texinfo )
{
	// brush.numsides is no longer valid.  Assume numsides == 6
	for ( int i = 0; i < 6; i++ )
	{
		dbrushside_t *side = pSides + i + brush.firstbrushside;
		cplane_t *plane = pPlanes + side->planenum;
		int t = side->texinfo;
		Assert(t<map_texinfo.Count());
		int surfaceIndex = (t<0) ? SURFACE_INDEX_INVALID : map_texinfo[t];
		int axis = plane->type;
		Assert(fabs(plane->normal[axis])==1.0f);
		if ( plane->normal[axis] == 1.0f )
		{
			pBox->maxs[axis] = plane->dist;
			pBox->surfaceIndex[axis+3] = surfaceIndex;
		}
		else if ( plane->normal[axis] == -1.0f )
		{
			pBox->mins[axis] = -plane->dist;
			pBox->surfaceIndex[axis] = surfaceIndex;
		}
		else
		{
			Assert(0);
		}
	}
	pBox->pad2[0] = 0;
	pBox->pad2[1] = 0;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadBrushSides( CCollisionBSPData *pBSPData, CUtlVector<unsigned short> &map_texinfo )
{
	CMapLoadHelper lh( LUMP_BRUSHSIDES );

	int				i, j;
	dbrushside_t 	*in;

	in = (dbrushside_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadBrushSides: funny lump size");
	}

	int inputSideCount = lh.LumpSize() / sizeof(*in);

	// need to save space for box planes
	if (inputSideCount > MAX_MAP_BRUSHSIDES)
	{
		Sys_Error( "Map has too many planes");
	}


	// Brushes are compressed on load to remove any AABB brushes.  The brushsides for those are removed
	// and those brushes are stored as cboxbrush_t.  But the texinfo/surface data needs to be copied
	// So the algorithm is:
	//
	// count box brushes
	// count total brush sides
	// allocate
	// iterate brushes and copy sides or fill out box brushes
	// done
	//

	int boxBrushCount = 0;
	int brushSideCount = 0;
	for ( i = 0; i < pBSPData->numbrushes; i++ )
	{
		if ( IsBoxBrush(pBSPData->map_brushes[i], in, pBSPData->map_planes.Base()) )
		{
			// mark as axial
			pBSPData->map_brushes[i].numsides = NUMSIDES_BOXBRUSH;
			boxBrushCount++;
		}
		else
		{
			brushSideCount += pBSPData->map_brushes[i].numsides;
		}
	}

	int nSize = brushSideCount * sizeof(cbrushside_t);
	pBSPData->map_brushsides.Attach( brushSideCount, (cbrushside_t*)Hunk_Alloc( nSize, false ) );
	pBSPData->map_boxbrushes.Attach( boxBrushCount, (cboxbrush_t*)Hunk_Alloc( boxBrushCount*sizeof(cboxbrush_t), false ) );

	pBSPData->numbrushsides = brushSideCount;
	pBSPData->numboxbrushes = boxBrushCount;

	int outBoxBrush = 0;
	int outBrushSide = 0;
	for ( i = 0; i < pBSPData->numbrushes; i++ )
	{
		cbrush_t *pBrush = &pBSPData->map_brushes[i];

		if ( pBrush->IsBox() )
		{
			// fill out the box brush - extract from the input sides
			cboxbrush_t *pBox = &pBSPData->map_boxbrushes[outBoxBrush];
			ExtractBoxBrush( pBox, *pBrush, in, pBSPData->map_planes.Base(), map_texinfo );
			pBrush->SetBox(outBoxBrush);
			outBoxBrush++;
		}
		else
		{
			// copy each side into the output array
			int firstInputSide = pBrush->firstbrushside;
			pBrush->firstbrushside = outBrushSide;
			for ( j = 0; j < pBrush->numsides; j++ )
			{
				cbrushside_t * RESTRICT pSide = &pBSPData->map_brushsides[outBrushSide];
				dbrushside_t * RESTRICT pInputSide = in + firstInputSide + j;
				pSide->plane = &pBSPData->map_planes[pInputSide->planenum];
				int t = pInputSide->texinfo;
				if (t >= map_texinfo.Size())
				{
					Sys_Error( "Bad brushside texinfo");
				}

				// BUGBUG: Why is vbsp writing out -1 as the texinfo id?  (TEXINFO_NODE ?)
				pSide->surfaceIndex = (t < 0) ? SURFACE_INDEX_INVALID : map_texinfo[t];
				pSide->bBevel = pInputSide->bevel ? true : false;
				outBrushSide++;
			}
		}
	}
	Assert( outBrushSide == pBSPData->numbrushsides && outBoxBrush == pBSPData->numboxbrushes );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadSubmodels( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_MODELS );

	dmodel_t	*in;
	int			i, j, count;

	in = (dmodel_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
		Sys_Error("CMod_LoadSubmodels: funny lump size");
	count = lh.LumpSize() / sizeof(*in);

	if (count < 1)
		Sys_Error( "Map with no models" );
	if (count > MAX_MAP_MODELS)
		Sys_Error( "Map has too many models" );

	int nSize = count * sizeof(cmodel_t);
	pBSPData->map_cmodels.Attach( count, (cmodel_t*)Hunk_Alloc( nSize ) );
	pBSPData->numcmodels = count;

	for ( i=0 ; i<count ; i++, in++ )
	{
		cmodel_t *out = &pBSPData->map_cmodels[i];

		for (j=0 ; j<3 ; j++)
		{	// spread the mins / maxs by a pixel
			out->mins[j] = in->mins[j] - 1;
			out->maxs[j] = in->maxs[j] + 1;
			out->origin[j] = in->origin[j];
		}
		out->headnode = in->headnode;
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadNodes( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_NODES );

	dnode_t		*in;
	int			i, j, count;
	
	in = (dnode_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
		Sys_Error( "CollisionBSPData_LoadNodes: funny lump size");
	count = lh.LumpSize() / sizeof(*in);

	if (count < 1)
		Sys_Error( "Map has no nodes");
	if (count > MAX_MAP_NODES)
		Sys_Error( "Map has too many nodes");

	// 6 extra for box hull
	int nSize = ( count + 6 ) * sizeof(cnode_t);
	pBSPData->map_nodes.Attach( count + 6, (cnode_t*)Hunk_Alloc( nSize ) );

	pBSPData->numnodes = count;
	pBSPData->map_rootnode = pBSPData->map_nodes.Base();

	for (i=0; i<count; i++, in++)
	{
		cnode_t	*out = &pBSPData->map_nodes[i];
		out->plane = &pBSPData->map_planes[ in->planenum ];
		for (j=0; j<2; j++)
		{
			out->children[j] = in->children[j];
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadAreas( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_AREAS );

	int			i;
	darea_t 	*in;
	int			count;

	in = (darea_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadAreas: funny lump size");
	}

	count = lh.LumpSize() / sizeof(*in);
	if (count > MAX_MAP_AREAS)
	{
		Sys_Error( "Map has too many areas");
	}

	int nSize = count * sizeof(carea_t);
	pBSPData->map_areas.Attach( count, (carea_t*)Hunk_Alloc( nSize ) );

	pBSPData->numareas = count;

	for ( i=0 ; i<count ; i++, in++)
	{
		carea_t	*out = &pBSPData->map_areas[i];
		out->numareaportals = in->numareaportals;
		out->firstareaportal = in->firstareaportal;
		out->floodvalid = 0;
		out->floodnum = 0;
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadAreaPortals( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_AREAPORTALS );

	dareaportal_t 	*in;
	int				count;

	in = (dareaportal_t *)lh.LumpBase();
	if (lh.LumpSize() % sizeof(*in))
	{
		Sys_Error( "CMod_LoadAreaPortals: funny lump size");
	}
		   
	count = lh.LumpSize() / sizeof(*in);
	if (count > MAX_MAP_AREAPORTALS)
	{
		Sys_Error( "Map has too many area portals");
	}

	// Need to add one more in owing to 1-based instead of 0-based data!
	++count;

	pBSPData->numportalopen = count;
	pBSPData->portalopen.Attach( count, (bool*)Hunk_Alloc( pBSPData->numportalopen * sizeof(bool), false ) );
	for ( int i=0; i < pBSPData->numportalopen; i++ )
	{
		pBSPData->portalopen[i] = false;
	}

	pBSPData->numareaportals = count;
	int nSize = count * sizeof(dareaportal_t);
	pBSPData->map_areaportals.Attach( count, (dareaportal_t*)Hunk_Alloc( nSize ) );

	Assert( nSize >= lh.LumpSize() ); 
	memcpy( pBSPData->map_areaportals.Base(), in, lh.LumpSize() );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadVisibility( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_VISIBILITY );

	pBSPData->numvisibility = lh.LumpSize();
	if (lh.LumpSize() > MAX_MAP_VISIBILITY)
		Sys_Error( "Map has too large visibility lump");

	int visDataSize = lh.LumpSize();
	if ( visDataSize == 0 )
	{
		pBSPData->map_vis = NULL;
	}
	else
	{
		pBSPData->map_vis = (dvis_t *) Hunk_Alloc( visDataSize, false );
		memcpy( pBSPData->map_vis, lh.LumpBase(), visDataSize );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadEntityString( CCollisionBSPData *pBSPData )
{
	CMapLoadHelper lh( LUMP_ENTITIES );

	pBSPData->numentitychars = lh.LumpSize();
	MEM_ALLOC_CREDIT();
	char szMapName[MAX_PATH] = { 0 };
	V_strncpy( szMapName, lh.GetMapName(), sizeof( szMapName ) );
	pBSPData->map_entitystring.Init( szMapName, lh.LumpOffset(), lh.LumpSize(), lh.LumpBase() );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadPhysics( CCollisionBSPData *pBSPData )
{
#ifdef _WIN32
	CMapLoadHelper lh( LUMP_PHYSCOLLIDE );
#else
	int nLoadLump = LUMP_PHYSCOLLIDE;
	// backwards compat support for older game dlls
	// they crash if they don't have vcollide data for terrain 
	// even though the new engine ignores it
	if ( g_iServerGameDLLVersion >= 5 )
	{
		// if there's a linux lump present, go ahead and load it
		// otherwise, the win32 lump will work as long as it doesn't have any
		// mopp surfaces in it (if compiled with the current vbsp.exe or a map without any displacements).  
		// The legacy server game DLLs will crash when mopps are present but since 
		// they also crash with a NULL lump there's nothing lost in that case.
		if ( CMapLoadHelper::LumpSize(LUMP_PHYSCOLLIDESURFACE) > 0 )
		{
			nLoadLump = LUMP_PHYSCOLLIDESURFACE;
		}
		else
		{
			DevWarning("Legacy game DLL may not support terrain vphysics collisions with this BSP!\n");
		}
	}

	CMapLoadHelper lh( nLoadLump );
#endif
	if ( !lh.LumpSize() )
		return;

	byte *ptr = lh.LumpBase();
	byte *basePtr = ptr;

	dphysmodel_t physModel;

	// physics data is variable length.  The last physmodel is a NULL pointer
	// with modelIndex -1, dataSize -1
	do
	{
		memcpy( &physModel, ptr, sizeof(physModel) );
		ptr += sizeof(physModel);

		if ( physModel.dataSize > 0 )
		{
			cmodel_t *pModel = &pBSPData->map_cmodels[ physModel.modelIndex ];
			physcollision->VCollideLoad( &pModel->vcollisionData, physModel.solidCount, (const char *)ptr, physModel.dataSize + physModel.keydataSize );
			ptr += physModel.dataSize;
			ptr += physModel.keydataSize;
		}
		
		// avoid infinite loop on badly formed file
		if ( (int)(ptr - basePtr) > lh.LumpSize() )
			break;

	} while ( physModel.dataSize > 0 );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionBSPData_LoadDispInfo( CCollisionBSPData *pBSPData )
{
	// How many displacements in the map?
	int coreDispCount = CMapLoadHelper::LumpSize( LUMP_DISPINFO ) / sizeof( ddispinfo_t );
	if ( coreDispCount == 0 )
		return;	

    //
    // get the vertex data
    //
 	CMapLoadHelper lhv( LUMP_VERTEXES );
	dvertex_t *pVerts = ( dvertex_t* )lhv.LumpBase();
	if ( lhv.LumpSize() % sizeof( dvertex_t ) )
		Sys_Error( "CMod_LoadDispInfo: bad vertex lump size!" );

    //
    // get the edge data
    //
 	CMapLoadHelper lhe( LUMP_EDGES );
    dedge_t *pEdges = ( dedge_t* )lhe.LumpBase();
    if ( lhe.LumpSize() % sizeof( dedge_t ) )
        Sys_Error( "CMod_LoadDispInfo: bad edge lump size!" );

    //
    // get surf edges data
    //
 	CMapLoadHelper lhs( LUMP_SURFEDGES );
    int *pSurfEdges = ( int* )lhs.LumpBase();
    if ( lhs.LumpSize() % sizeof( int ) )
        Sys_Error( "CMod_LoadDispInfo: bad surf edge lump size!" );

    //
    // get face data
    //
	int face_lump_to_load = LUMP_FACES;
	if ( g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE &&
		CMapLoadHelper::LumpSize( LUMP_FACES_HDR ) > 0 )
	{
		face_lump_to_load = LUMP_FACES_HDR;
	}
	CMapLoadHelper lhf( face_lump_to_load );
    dface_t *pFaces = ( dface_t* )lhf.LumpBase();
    if ( lhf.LumpSize() % sizeof( dface_t ) )
        Sys_Error( "CMod_LoadDispInfo: bad face lump size!" );
    int faceCount = lhf.LumpSize() / sizeof( dface_t );

	dface_t *pFaceList = pFaces;
	if ( !pFaceList )
		return;

    //
    // get texinfo data
    //
 	CMapLoadHelper lhti( LUMP_TEXINFO );
    texinfo_t *pTexinfoList = ( texinfo_t* )lhti.LumpBase();
    if ( lhti.LumpSize() % sizeof( texinfo_t ) )
        Sys_Error( "CMod_LoadDispInfo: bad texinfo lump size!" );

	// allocate displacement collision trees
	g_DispCollTreeCount = coreDispCount;
	g_pDispCollTrees = DispCollTrees_Alloc( g_DispCollTreeCount );
	g_pDispBounds = (alignedbbox_t *)Hunk_Alloc( g_DispCollTreeCount * sizeof(alignedbbox_t), false );

	// Build the inverse mapping from disp index to face
	int nMemSize = coreDispCount * sizeof(unsigned short);
	unsigned short *pDispIndexToFaceIndex = (unsigned short*)stackalloc( nMemSize );
	memset( pDispIndexToFaceIndex, 0xFF, nMemSize );
	
	int i;
    for ( i = 0; i < faceCount; ++i, ++pFaces )
    {
        // check face for displacement data
        if ( pFaces->dispinfo == -1 )
            continue;

        // get the current displacement build surface
		if ( pFaces->dispinfo >= coreDispCount )
			continue;

		pDispIndexToFaceIndex[pFaces->dispinfo] = (unsigned short)i;
    }

	// Load one dispinfo from disk at a time and set it up.
	int iCurVert = 0;
	int iCurTri = 0;
	CDispVert tempVerts[MAX_DISPVERTS];
	CDispTri  tempTris[MAX_DISPTRIS];

	int nSize = 0;
	int nCacheSize = 0;
	int nPowerCount[3] = { 0, 0, 0 };

	CMapLoadHelper lhDispInfo( LUMP_DISPINFO );
	CMapLoadHelper lhDispVerts( LUMP_DISP_VERTS );
	CMapLoadHelper lhDispTris( LUMP_DISP_TRIS );

	for ( i = 0; i < coreDispCount; ++i )
	{
		// Find the face associated with this dispinfo
		unsigned short nFaceIndex = pDispIndexToFaceIndex[i];
		if ( nFaceIndex == 0xFFFF )
			continue;

		// Load up the dispinfo and create the CCoreDispInfo from it.
		ddispinfo_t dispInfo;
		lhDispInfo.LoadLumpElement( i, sizeof(ddispinfo_t), &dispInfo );

		// Read in the vertices.
		int nVerts = NUM_DISP_POWER_VERTS( dispInfo.power );
		lhDispVerts.LoadLumpData( iCurVert * sizeof(CDispVert), nVerts*sizeof(CDispVert), tempVerts );
		iCurVert += nVerts;
		
		// Read in the tris.
		int nTris = NUM_DISP_POWER_TRIS( dispInfo.power );
		lhDispTris.LoadLumpData( iCurTri * sizeof( CDispTri ), nTris*sizeof( CDispTri), tempTris );
		iCurTri += nTris;

		CCoreDispInfo coreDisp;
		CCoreDispSurface *pDispSurf = coreDisp.GetSurface();
		pDispSurf->SetPointStart( dispInfo.startPosition );
		pDispSurf->SetContents( dispInfo.contents );
	
		coreDisp.InitDispInfo( dispInfo.power, dispInfo.minTess, dispInfo.smoothingAngle, tempVerts, tempTris );

		// Hook the disp surface to the face
		pFaces = &pFaceList[ nFaceIndex ];
		pDispSurf->SetHandle( nFaceIndex );

		// get points
		if ( pFaces->numedges > 4 )
			continue;

		Vector surfPoints[4];
		pDispSurf->SetPointCount( pFaces->numedges );
		int j;
		for ( j = 0; j < pFaces->numedges; j++ )
		{
			int eIndex = pSurfEdges[pFaces->firstedge+j];
			if ( eIndex < 0 )
			{
				VectorCopy( pVerts[pEdges[-eIndex].v[1]].point, surfPoints[j] );
			}
			else
			{
				VectorCopy( pVerts[pEdges[eIndex].v[0]].point, surfPoints[j] );
			}
		}

		for ( j = 0; j < 4; j++ )
		{
			pDispSurf->SetPoint( j, surfPoints[j] );
		}

		pDispSurf->FindSurfPointStartIndex();
		pDispSurf->AdjustSurfPointData();

		//
		// generate the collision displacement surfaces
		//
		CDispCollTree *pDispTree = &g_pDispCollTrees[i];
		pDispTree->SetPower( 0 );

		//
		// check for null faces, should have been taken care of in vbsp!!!
		//
		int pointCount = pDispSurf->GetPointCount();
		if ( pointCount != 4 )
			continue;

		coreDisp.Create();

		// new collision
		pDispTree->Create( &coreDisp );
		g_pDispBounds[i].Init(pDispTree->m_mins, pDispTree->m_maxs, pDispTree->m_iCounter, pDispTree->GetContents());
		nSize += pDispTree->GetMemorySize();
		nCacheSize += pDispTree->GetCacheMemorySize();
		nPowerCount[pDispTree->GetPower()-2]++;

		// Surface props.
		texinfo_t *pTex = &pTexinfoList[pFaces->texinfo];
		if ( pTex->texdata >= 0 )
		{
			IMaterial *pMaterial = materials->FindMaterial( pBSPData->map_surfaces[pTex->texdata].name, TEXTURE_GROUP_WORLD, true );
			if ( !IsErrorMaterial( pMaterial ) )
			{
				IMaterialVar *pVar;
				bool bVarFound;
				pVar = pMaterial->FindVar( "$surfaceprop", &bVarFound, false );
				if ( bVarFound )
				{
					const char *pProps = pVar->GetStringValue();
					pDispTree->SetSurfaceProps( 0, physprop->GetSurfaceIndex( pProps ) );
					pDispTree->SetSurfaceProps( 1, physprop->GetSurfaceIndex( pProps ) );
				}

				pVar = pMaterial->FindVar( "$surfaceprop2", &bVarFound, false );
				if ( bVarFound )
				{
					const char *pProps = pVar->GetStringValue();
					pDispTree->SetSurfaceProps( 1, physprop->GetSurfaceIndex( pProps ) );
				}
			}
		}
	}

	CMapLoadHelper lhDispPhys( LUMP_PHYSDISP );
	dphysdisp_t *pDispPhys = (dphysdisp_t *)lhDispPhys.LumpBase();
	// create the vphysics collision models for each displacement
	CM_CreateDispPhysCollide( pDispPhys, lhDispPhys.LumpSize() );
}


//=============================================================================
//
// Collision Count Functions
//

#ifdef COUNT_COLLISIONS
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CollisionCounts_Init( CCollisionCounts *pCounts )
{
	pCounts->m_PointContents = 0;
	pCounts->m_Traces = 0;
	pCounts->m_BrushTraces = 0;
	pCounts->m_DispTraces = 0;
	pCounts->m_Stabs = 0;
}
#endif