source-engine/engine/cmodel_bsp.cpp

1307 lines
36 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= 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 );
2020-04-22 16:56:21 +00:00
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;
2022-04-16 09:54:00 +00:00
if ( g_pMaterialSystemHardwareConfig->GetHDREnabled() && /*g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE &&*/
2020-04-22 16:56:21 +00:00
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