mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-24 05:11:21 +00:00
1314 lines
33 KiB
C++
1314 lines
33 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "AASFile.h"
|
|
#include "AASFile_local.h"
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idReachability
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
================
|
|
Reachability_Write
|
|
================
|
|
*/
|
|
bool Reachability_Write( idFile *fp, idReachability *reach ) {
|
|
fp->WriteFloatString( "\t\t%d %d (%f %f %f) (%f %f %f) %d %d",
|
|
(int) reach->travelType, (int) reach->toAreaNum, reach->start.x, reach->start.y, reach->start.z,
|
|
reach->end.x, reach->end.y, reach->end.z, reach->edgeNum, (int) reach->travelTime );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Reachability_Read
|
|
================
|
|
*/
|
|
bool Reachability_Read( idLexer &src, idReachability *reach ) {
|
|
reach->travelType = src.ParseInt();
|
|
reach->toAreaNum = src.ParseInt();
|
|
src.Parse1DMatrix( 3, reach->start.ToFloatPtr() );
|
|
src.Parse1DMatrix( 3, reach->end.ToFloatPtr() );
|
|
reach->edgeNum = src.ParseInt();
|
|
reach->travelTime = src.ParseInt();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idReachability::CopyBase
|
|
================
|
|
*/
|
|
void idReachability::CopyBase( idReachability &reach ) {
|
|
travelType = reach.travelType;
|
|
toAreaNum = reach.toAreaNum;
|
|
start = reach.start;
|
|
end = reach.end;
|
|
edgeNum = reach.edgeNum;
|
|
travelTime = reach.travelTime;
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idReachability_Special
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
================
|
|
Reachability_Special_Write
|
|
================
|
|
*/
|
|
bool Reachability_Special_Write( idFile *fp, idReachability_Special *reach ) {
|
|
int i;
|
|
const idKeyValue *keyValue;
|
|
|
|
fp->WriteFloatString( "\n\t\t{\n" );
|
|
for ( i = 0; i < reach->dict.GetNumKeyVals(); i++ ) {
|
|
keyValue = reach->dict.GetKeyVal( i );
|
|
fp->WriteFloatString( "\t\t\t\"%s\" \"%s\"\n", keyValue->GetKey().c_str(), keyValue->GetValue().c_str() );
|
|
}
|
|
fp->WriteFloatString( "\t\t}\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Reachability_Special_Read
|
|
================
|
|
*/
|
|
bool Reachability_Special_Read( idLexer &src, idReachability_Special *reach ) {
|
|
idToken key, value;
|
|
|
|
src.ExpectTokenString( "{" );
|
|
while( src.ReadToken( &key ) ) {
|
|
if ( key == "}" ) {
|
|
return true;
|
|
}
|
|
src.ExpectTokenType( TT_STRING, 0, &value );
|
|
reach->dict.Set( key, value );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAASSettings
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAASSettings::idAASSettings
|
|
============
|
|
*/
|
|
idAASSettings::idAASSettings( void ) {
|
|
numBoundingBoxes = 1;
|
|
boundingBoxes[0] = idBounds( idVec3( -16, -16, 0 ), idVec3( 16, 16, 72 ) );
|
|
usePatches = false;
|
|
writeBrushMap = false;
|
|
playerFlood = false;
|
|
noOptimize = false;
|
|
allowSwimReachabilities = false;
|
|
allowFlyReachabilities = false;
|
|
fileExtension = "aas48";
|
|
// physics settings
|
|
gravity = idVec3( 0, 0, -1066 );
|
|
gravityDir = gravity;
|
|
gravityValue = gravityDir.Normalize();
|
|
invGravityDir = -gravityDir;
|
|
maxStepHeight = 14.0f;
|
|
maxBarrierHeight = 32.0f;
|
|
maxWaterJumpHeight = 20.0f;
|
|
maxFallHeight = 64.0f;
|
|
minFloorCos = 0.7f;
|
|
// fixed travel times
|
|
tt_barrierJump = 100;
|
|
tt_startCrouching = 100;
|
|
tt_waterJump = 100;
|
|
tt_startWalkOffLedge = 100;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ParseBool
|
|
============
|
|
*/
|
|
bool idAASSettings::ParseBool( idLexer &src, bool &b ) {
|
|
if ( !src.ExpectTokenString( "=" ) ) {
|
|
return false;
|
|
}
|
|
b = src.ParseBool();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ParseInt
|
|
============
|
|
*/
|
|
bool idAASSettings::ParseInt( idLexer &src, int &i ) {
|
|
if ( !src.ExpectTokenString( "=" ) ) {
|
|
return false;
|
|
}
|
|
i = src.ParseInt();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ParseFloat
|
|
============
|
|
*/
|
|
bool idAASSettings::ParseFloat( idLexer &src, float &f ) {
|
|
if ( !src.ExpectTokenString( "=" ) ) {
|
|
return false;
|
|
}
|
|
f = src.ParseFloat();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ParseVector
|
|
============
|
|
*/
|
|
bool idAASSettings::ParseVector( idLexer &src, idVec3 &vec ) {
|
|
if ( !src.ExpectTokenString( "=" ) ) {
|
|
return false;
|
|
}
|
|
return ( src.Parse1DMatrix( 3, vec.ToFloatPtr() ) != 0 );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ParseBBoxes
|
|
============
|
|
*/
|
|
bool idAASSettings::ParseBBoxes( idLexer &src ) {
|
|
idToken token;
|
|
idBounds bounds;
|
|
|
|
numBoundingBoxes = 0;
|
|
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
while( src.ReadToken( &token ) ) {
|
|
if ( token == "}" ) {
|
|
return true;
|
|
}
|
|
src.UnreadToken( &token );
|
|
src.Parse1DMatrix( 3, bounds[0].ToFloatPtr() );
|
|
if ( !src.ExpectTokenString( "-" ) ) {
|
|
return false;
|
|
}
|
|
src.Parse1DMatrix( 3, bounds[1].ToFloatPtr() );
|
|
|
|
boundingBoxes[numBoundingBoxes++] = bounds;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::FromParser
|
|
============
|
|
*/
|
|
bool idAASSettings::FromParser( idLexer &src ) {
|
|
idToken token;
|
|
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
|
|
// parse the file
|
|
while ( 1 ) {
|
|
if ( !src.ReadToken( &token ) ) {
|
|
break;
|
|
}
|
|
|
|
if ( token == "}" ) {
|
|
break;
|
|
}
|
|
|
|
if ( token == "bboxes" ) {
|
|
if ( !ParseBBoxes( src ) ) { return false; }
|
|
}
|
|
else if ( token == "usePatches" ) {
|
|
if ( !ParseBool( src, usePatches ) ) { return false; }
|
|
}
|
|
else if ( token == "writeBrushMap" ) {
|
|
if ( !ParseBool( src, writeBrushMap ) ) { return false; }
|
|
}
|
|
else if ( token == "playerFlood" ) {
|
|
if ( !ParseBool( src, playerFlood ) ) { return false; }
|
|
}
|
|
else if ( token == "allowSwimReachabilities" ) {
|
|
if ( !ParseBool( src, allowSwimReachabilities ) ) { return false; }
|
|
}
|
|
else if ( token == "allowFlyReachabilities" ) {
|
|
if ( !ParseBool( src, allowFlyReachabilities ) ) { return false; }
|
|
}
|
|
else if ( token == "fileExtension" ) {
|
|
src.ExpectTokenString( "=" );
|
|
src.ExpectTokenType( TT_STRING, 0, &token );
|
|
fileExtension = token;
|
|
}
|
|
else if ( token == "gravity" ) {
|
|
ParseVector( src, gravity );
|
|
gravityDir = gravity;
|
|
gravityValue = gravityDir.Normalize();
|
|
invGravityDir = -gravityDir;
|
|
}
|
|
else if ( token == "maxStepHeight" ) {
|
|
if ( !ParseFloat( src, maxStepHeight ) ) { return false; }
|
|
}
|
|
else if ( token == "maxBarrierHeight" ) {
|
|
if ( !ParseFloat( src, maxBarrierHeight ) ) { return false; }
|
|
}
|
|
else if ( token == "maxWaterJumpHeight" ) {
|
|
if ( !ParseFloat( src, maxWaterJumpHeight ) ) { return false; }
|
|
}
|
|
else if ( token == "maxFallHeight" ) {
|
|
if ( !ParseFloat( src, maxFallHeight ) ) { return false; }
|
|
}
|
|
else if ( token == "minFloorCos" ) {
|
|
if ( !ParseFloat( src, minFloorCos ) ) { return false; }
|
|
}
|
|
else if ( token == "tt_barrierJump" ) {
|
|
if ( !ParseInt( src, tt_barrierJump ) ) { return false; }
|
|
}
|
|
else if ( token == "tt_startCrouching" ) {
|
|
if ( !ParseInt( src, tt_startCrouching ) ) { return false; }
|
|
}
|
|
else if ( token == "tt_waterJump" ) {
|
|
if ( !ParseInt( src, tt_waterJump ) ) { return false; }
|
|
}
|
|
else if ( token == "tt_startWalkOffLedge" ) {
|
|
if ( !ParseInt( src, tt_startWalkOffLedge ) ) { return false; }
|
|
}
|
|
else {
|
|
src.Error( "invalid token '%s'", token.c_str() );
|
|
}
|
|
}
|
|
|
|
if ( numBoundingBoxes <= 0 ) {
|
|
src.Error( "no valid bounding box" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::FromFile
|
|
============
|
|
*/
|
|
bool idAASSettings::FromFile( const idStr &fileName ) {
|
|
idLexer src( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS | LEXFL_NOSTRINGCONCAT );
|
|
idStr name;
|
|
|
|
name = fileName;
|
|
|
|
common->Printf( "loading %s\n", name.c_str() );
|
|
|
|
if ( !src.LoadFile( name ) ) {
|
|
common->Error( "WARNING: couldn't load %s\n", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
if ( !src.ExpectTokenString( "settings" ) ) {
|
|
common->Error( "%s is not a settings file", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
if ( !FromParser( src ) ) {
|
|
common->Error( "failed to parse %s", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::FromDict
|
|
============
|
|
*/
|
|
bool idAASSettings::FromDict( const char *name, const idDict *dict ) {
|
|
idBounds bounds;
|
|
|
|
if ( !dict->GetVector( "mins", "0 0 0", bounds[ 0 ] ) ) {
|
|
common->Error( "Missing 'mins' in entityDef '%s'", name );
|
|
}
|
|
if ( !dict->GetVector( "maxs", "0 0 0", bounds[ 1 ] ) ) {
|
|
common->Error( "Missing 'maxs' in entityDef '%s'", name );
|
|
}
|
|
|
|
numBoundingBoxes = 1;
|
|
boundingBoxes[0] = bounds;
|
|
|
|
if ( !dict->GetBool( "usePatches", "0", usePatches ) ) {
|
|
common->Error( "Missing 'usePatches' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetBool( "writeBrushMap", "0", writeBrushMap ) ) {
|
|
common->Error( "Missing 'writeBrushMap' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetBool( "playerFlood", "0", playerFlood ) ) {
|
|
common->Error( "Missing 'playerFlood' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetBool( "allowSwimReachabilities", "0", allowSwimReachabilities ) ) {
|
|
common->Error( "Missing 'allowSwimReachabilities' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetBool( "allowFlyReachabilities", "0", allowFlyReachabilities ) ) {
|
|
common->Error( "Missing 'allowFlyReachabilities' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetString( "fileExtension", "", fileExtension ) ) {
|
|
common->Error( "Missing 'fileExtension' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetVector( "gravity", "0 0 -1066", gravity ) ) {
|
|
common->Error( "Missing 'gravity' in entityDef '%s'", name );
|
|
}
|
|
gravityDir = gravity;
|
|
gravityValue = gravityDir.Normalize();
|
|
invGravityDir = -gravityDir;
|
|
|
|
if ( !dict->GetFloat( "maxStepHeight", "0", maxStepHeight ) ) {
|
|
common->Error( "Missing 'maxStepHeight' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetFloat( "maxBarrierHeight", "0", maxBarrierHeight ) ) {
|
|
common->Error( "Missing 'maxBarrierHeight' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetFloat( "maxWaterJumpHeight", "0", maxWaterJumpHeight ) ) {
|
|
common->Error( "Missing 'maxWaterJumpHeight' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetFloat( "maxFallHeight", "0", maxFallHeight ) ) {
|
|
common->Error( "Missing 'maxFallHeight' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetFloat( "minFloorCos", "0", minFloorCos ) ) {
|
|
common->Error( "Missing 'minFloorCos' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetInt( "tt_barrierJump", "0", tt_barrierJump ) ) {
|
|
common->Error( "Missing 'tt_barrierJump' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetInt( "tt_startCrouching", "0", tt_startCrouching ) ) {
|
|
common->Error( "Missing 'tt_startCrouching' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetInt( "tt_waterJump", "0", tt_waterJump ) ) {
|
|
common->Error( "Missing 'tt_waterJump' in entityDef '%s'", name );
|
|
}
|
|
|
|
if ( !dict->GetInt( "tt_startWalkOffLedge", "0", tt_startWalkOffLedge ) ) {
|
|
common->Error( "Missing 'tt_startWalkOffLedge' in entityDef '%s'", name );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idAASSettings::WriteToFile
|
|
============
|
|
*/
|
|
bool idAASSettings::WriteToFile( idFile *fp ) const {
|
|
int i;
|
|
|
|
fp->WriteFloatString( "{\n" );
|
|
fp->WriteFloatString( "\tbboxes\n\t{\n" );
|
|
for ( i = 0; i < numBoundingBoxes; i++ ) {
|
|
fp->WriteFloatString( "\t\t(%f %f %f)-(%f %f %f)\n", boundingBoxes[i][0].x, boundingBoxes[i][0].y,
|
|
boundingBoxes[i][0].z, boundingBoxes[i][1].x, boundingBoxes[i][1].y, boundingBoxes[i][1].z );
|
|
}
|
|
fp->WriteFloatString( "\t}\n" );
|
|
fp->WriteFloatString( "\tusePatches = %d\n", usePatches );
|
|
fp->WriteFloatString( "\twriteBrushMap = %d\n", writeBrushMap );
|
|
fp->WriteFloatString( "\tplayerFlood = %d\n", playerFlood );
|
|
fp->WriteFloatString( "\tallowSwimReachabilities = %d\n", allowSwimReachabilities );
|
|
fp->WriteFloatString( "\tallowFlyReachabilities = %d\n", allowFlyReachabilities );
|
|
fp->WriteFloatString( "\tfileExtension = \"%s\"\n", fileExtension.c_str() );
|
|
fp->WriteFloatString( "\tgravity = (%f %f %f)\n", gravity.x, gravity.y, gravity.z );
|
|
fp->WriteFloatString( "\tmaxStepHeight = %f\n", maxStepHeight );
|
|
fp->WriteFloatString( "\tmaxBarrierHeight = %f\n", maxBarrierHeight );
|
|
fp->WriteFloatString( "\tmaxWaterJumpHeight = %f\n", maxWaterJumpHeight );
|
|
fp->WriteFloatString( "\tmaxFallHeight = %f\n", maxFallHeight );
|
|
fp->WriteFloatString( "\tminFloorCos = %f\n", minFloorCos );
|
|
fp->WriteFloatString( "\ttt_barrierJump = %d\n", tt_barrierJump );
|
|
fp->WriteFloatString( "\ttt_startCrouching = %d\n", tt_startCrouching );
|
|
fp->WriteFloatString( "\ttt_waterJump = %d\n", tt_waterJump );
|
|
fp->WriteFloatString( "\ttt_startWalkOffLedge = %d\n", tt_startWalkOffLedge );
|
|
fp->WriteFloatString( "}\n" );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ValidForBounds
|
|
============
|
|
*/
|
|
bool idAASSettings::ValidForBounds( const idBounds &bounds ) const {
|
|
int i;
|
|
|
|
for ( i = 0; i < 3; i++ ) {
|
|
if ( bounds[0][i] < boundingBoxes[0][0][i] ) {
|
|
return false;
|
|
}
|
|
if ( bounds[1][i] > boundingBoxes[0][1][i] ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASSettings::ValidEntity
|
|
============
|
|
*/
|
|
bool idAASSettings::ValidEntity( const char *classname ) const {
|
|
idStr use_aas;
|
|
idVec3 size;
|
|
idBounds bounds;
|
|
|
|
if ( playerFlood ) {
|
|
if ( !strcmp( classname, "info_player_start" ) || !strcmp( classname , "info_player_deathmatch" ) || !strcmp( classname, "func_teleporter" ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
const idDeclEntityDef *decl = static_cast<const idDeclEntityDef *>( declManager->FindType( DECL_ENTITYDEF, classname, false ) );
|
|
if ( decl && decl->dict.GetString( "use_aas", NULL, use_aas ) && !fileExtension.Icmp( use_aas ) ) {
|
|
if ( decl->dict.GetVector( "mins", NULL, bounds[0] ) ) {
|
|
decl->dict.GetVector( "maxs", NULL, bounds[1] );
|
|
} else if ( decl->dict.GetVector( "size", NULL, size ) ) {
|
|
bounds[ 0 ].Set( size.x * -0.5f, size.y * -0.5f, 0.0f );
|
|
bounds[ 1 ].Set( size.x * 0.5f, size.y * 0.5f, size.z );
|
|
}
|
|
|
|
if ( !ValidForBounds( bounds ) ) {
|
|
common->Error( "%s cannot use %s\n", classname, fileExtension.c_str() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAASFileLocal
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
#define AAS_LIST_GRANULARITY 1024
|
|
#define AAS_INDEX_GRANULARITY 4096
|
|
#define AAS_PLANE_GRANULARITY 4096
|
|
#define AAS_VERTEX_GRANULARITY 4096
|
|
#define AAS_EDGE_GRANULARITY 4096
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::idAASFileLocal
|
|
================
|
|
*/
|
|
idAASFileLocal::idAASFileLocal( void ) {
|
|
planeList.SetGranularity( AAS_PLANE_GRANULARITY );
|
|
vertices.SetGranularity( AAS_VERTEX_GRANULARITY );
|
|
edges.SetGranularity( AAS_EDGE_GRANULARITY );
|
|
edgeIndex.SetGranularity( AAS_INDEX_GRANULARITY );
|
|
faces.SetGranularity( AAS_LIST_GRANULARITY );
|
|
faceIndex.SetGranularity( AAS_INDEX_GRANULARITY );
|
|
areas.SetGranularity( AAS_LIST_GRANULARITY );
|
|
nodes.SetGranularity( AAS_LIST_GRANULARITY );
|
|
portals.SetGranularity( AAS_LIST_GRANULARITY );
|
|
portalIndex.SetGranularity( AAS_INDEX_GRANULARITY );
|
|
clusters.SetGranularity( AAS_LIST_GRANULARITY );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::~idAASFileLocal
|
|
================
|
|
*/
|
|
idAASFileLocal::~idAASFileLocal( void ) {
|
|
int i;
|
|
idReachability *reach, *next;
|
|
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
for ( reach = areas[i].reach; reach; reach = next ) {
|
|
next = reach->next;
|
|
delete reach;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::Clear
|
|
================
|
|
*/
|
|
void idAASFileLocal::Clear( void ) {
|
|
planeList.Clear();
|
|
vertices.Clear();
|
|
edges.Clear();
|
|
edgeIndex.Clear();
|
|
faces.Clear();
|
|
faceIndex.Clear();
|
|
areas.Clear();
|
|
nodes.Clear();
|
|
portals.Clear();
|
|
portalIndex.Clear();
|
|
clusters.Clear();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::Write
|
|
================
|
|
*/
|
|
bool idAASFileLocal::Write( const idStr &fileName, unsigned int mapFileCRC ) {
|
|
int i, num;
|
|
idFile *aasFile;
|
|
idReachability *reach;
|
|
|
|
common->Printf( "[Write AAS]\n" );
|
|
common->Printf( "writing %s\n", fileName.c_str() );
|
|
|
|
name = fileName;
|
|
crc = mapFileCRC;
|
|
|
|
aasFile = fileSystem->OpenFileWrite( fileName, "fs_devpath" );
|
|
if ( !aasFile ) {
|
|
common->Error( "Error opening %s", fileName.c_str() );
|
|
return false;
|
|
}
|
|
|
|
aasFile->WriteFloatString( "%s \"%s\"\n\n", AAS_FILEID, AAS_FILEVERSION );
|
|
aasFile->WriteFloatString( "%u\n\n", mapFileCRC );
|
|
|
|
// write out the settings
|
|
aasFile->WriteFloatString( "settings\n" );
|
|
settings.WriteToFile( aasFile );
|
|
|
|
// write out planes
|
|
aasFile->WriteFloatString( "planes %d {\n", planeList.Num() );
|
|
for ( i = 0; i < planeList.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %f %f %f %f )\n", i,
|
|
planeList[i].Normal().x, planeList[i].Normal().y, planeList[i].Normal().z, planeList[i].Dist() );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out vertices
|
|
aasFile->WriteFloatString( "vertices %d {\n", vertices.Num() );
|
|
for ( i = 0; i < vertices.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %f %f %f )\n", i, vertices[i].x, vertices[i].y, vertices[i].z );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out edges
|
|
aasFile->WriteFloatString( "edges %d {\n", edges.Num() );
|
|
for ( i = 0; i < edges.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d %d )\n", i, edges[i].vertexNum[0], edges[i].vertexNum[1] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out edgeIndex
|
|
aasFile->WriteFloatString( "edgeIndex %d {\n", edgeIndex.Num() );
|
|
for ( i = 0; i < edgeIndex.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d )\n", i, edgeIndex[i] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out faces
|
|
aasFile->WriteFloatString( "faces %d {\n", faces.Num() );
|
|
for ( i = 0; i < faces.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d %d )\n", i, faces[i].planeNum, faces[i].flags,
|
|
faces[i].areas[0], faces[i].areas[1], faces[i].firstEdge, faces[i].numEdges );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out faceIndex
|
|
aasFile->WriteFloatString( "faceIndex %d {\n", faceIndex.Num() );
|
|
for ( i = 0; i < faceIndex.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d )\n", i, faceIndex[i] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out areas
|
|
aasFile->WriteFloatString( "areas %d {\n", areas.Num() );
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
for ( num = 0, reach = areas[i].reach; reach; reach = reach->next ) {
|
|
num++;
|
|
}
|
|
aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d %d ) %d {\n", i, areas[i].flags, areas[i].contents,
|
|
areas[i].firstFace, areas[i].numFaces, areas[i].cluster, areas[i].clusterAreaNum, num );
|
|
for ( reach = areas[i].reach; reach; reach = reach->next ) {
|
|
Reachability_Write( aasFile, reach );
|
|
switch( reach->travelType ) {
|
|
case TFL_SPECIAL:
|
|
Reachability_Special_Write( aasFile, static_cast<idReachability_Special *>(reach) );
|
|
break;
|
|
}
|
|
aasFile->WriteFloatString( "\n" );
|
|
}
|
|
aasFile->WriteFloatString( "\t}\n" );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out nodes
|
|
aasFile->WriteFloatString( "nodes %d {\n", nodes.Num() );
|
|
for ( i = 0; i < nodes.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d %d %d )\n", i, nodes[i].planeNum, nodes[i].children[0], nodes[i].children[1] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out portals
|
|
aasFile->WriteFloatString( "portals %d {\n", portals.Num() );
|
|
for ( i = 0; i < portals.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d )\n", i, portals[i].areaNum, portals[i].clusters[0],
|
|
portals[i].clusters[1], portals[i].clusterAreaNum[0], portals[i].clusterAreaNum[1] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out portalIndex
|
|
aasFile->WriteFloatString( "portalIndex %d {\n", portalIndex.Num() );
|
|
for ( i = 0; i < portalIndex.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d )\n", i, portalIndex[i] );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// write out clusters
|
|
aasFile->WriteFloatString( "clusters %d {\n", clusters.Num() );
|
|
for ( i = 0; i < clusters.Num(); i++ ) {
|
|
aasFile->WriteFloatString( "\t%d ( %d %d %d %d )\n", i, clusters[i].numAreas, clusters[i].numReachableAreas,
|
|
clusters[i].firstPortal, clusters[i].numPortals );
|
|
}
|
|
aasFile->WriteFloatString( "}\n" );
|
|
|
|
// close file
|
|
fileSystem->CloseFile( aasFile );
|
|
|
|
common->Printf( "done.\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseIndex
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseIndex( idLexer &src, idList<aasIndex_t> &indexes ) {
|
|
int numIndexes, i;
|
|
aasIndex_t index;
|
|
|
|
numIndexes = src.ParseInt();
|
|
indexes.Resize( numIndexes );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numIndexes; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
index = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
indexes.Append( index );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParsePlanes
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParsePlanes( idLexer &src ) {
|
|
int numPlanes, i;
|
|
idPlane plane;
|
|
idVec4 vec;
|
|
|
|
numPlanes = src.ParseInt();
|
|
planeList.Resize( numPlanes );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numPlanes; i++ ) {
|
|
src.ParseInt();
|
|
if ( !src.Parse1DMatrix( 4, vec.ToFloatPtr() ) ) {
|
|
return false;
|
|
}
|
|
plane.SetNormal( vec.ToVec3() );
|
|
plane.SetDist( vec[3] );
|
|
planeList.Append( plane );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseVertices
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseVertices( idLexer &src ) {
|
|
int numVertices, i;
|
|
idVec3 vec;
|
|
|
|
numVertices = src.ParseInt();
|
|
vertices.Resize( numVertices );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numVertices; i++ ) {
|
|
src.ParseInt();
|
|
if ( !src.Parse1DMatrix( 3, vec.ToFloatPtr() ) ) {
|
|
return false;
|
|
}
|
|
vertices.Append( vec );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseEdges
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseEdges( idLexer &src ) {
|
|
int numEdges, i;
|
|
aasEdge_t edge;
|
|
|
|
numEdges = src.ParseInt();
|
|
edges.Resize( numEdges );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numEdges; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
edge.vertexNum[0] = src.ParseInt();
|
|
edge.vertexNum[1] = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
edges.Append( edge );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseFaces
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseFaces( idLexer &src ) {
|
|
int numFaces, i;
|
|
aasFace_t face;
|
|
|
|
numFaces = src.ParseInt();
|
|
faces.Resize( numFaces );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numFaces; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
face.planeNum = src.ParseInt();
|
|
face.flags = src.ParseInt();
|
|
face.areas[0] = src.ParseInt();
|
|
face.areas[1] = src.ParseInt();
|
|
face.firstEdge = src.ParseInt();
|
|
face.numEdges = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
faces.Append( face );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseReachabilities
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseReachabilities( idLexer &src, int areaNum ) {
|
|
int num, j;
|
|
aasArea_t *area;
|
|
idReachability reach, *newReach;
|
|
idReachability_Special *special;
|
|
|
|
area = &areas[areaNum];
|
|
|
|
num = src.ParseInt();
|
|
src.ExpectTokenString( "{" );
|
|
area->reach = NULL;
|
|
area->rev_reach = NULL;
|
|
area->travelFlags = AreaContentsTravelFlags( areaNum );
|
|
for ( j = 0; j < num; j++ ) {
|
|
Reachability_Read( src, &reach );
|
|
switch( reach.travelType ) {
|
|
case TFL_SPECIAL:
|
|
newReach = special = new idReachability_Special();
|
|
Reachability_Special_Read( src, special );
|
|
break;
|
|
default:
|
|
newReach = new idReachability();
|
|
break;
|
|
}
|
|
newReach->CopyBase( reach );
|
|
newReach->fromAreaNum = areaNum;
|
|
newReach->next = area->reach;
|
|
area->reach = newReach;
|
|
}
|
|
src.ExpectTokenString( "}" );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::LinkReversedReachability
|
|
================
|
|
*/
|
|
void idAASFileLocal::LinkReversedReachability( void ) {
|
|
int i;
|
|
idReachability *reach;
|
|
|
|
// link reversed reachabilities
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
for ( reach = areas[i].reach; reach; reach = reach->next ) {
|
|
reach->rev_next = areas[reach->toAreaNum].rev_reach;
|
|
areas[reach->toAreaNum].rev_reach = reach;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseAreas
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseAreas( idLexer &src ) {
|
|
int numAreas, i;
|
|
aasArea_t area;
|
|
|
|
numAreas = src.ParseInt();
|
|
areas.Resize( numAreas );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numAreas; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
area.flags = src.ParseInt();
|
|
area.contents = src.ParseInt();
|
|
area.firstFace = src.ParseInt();
|
|
area.numFaces = src.ParseInt();
|
|
area.cluster = src.ParseInt();
|
|
area.clusterAreaNum = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
areas.Append( area );
|
|
ParseReachabilities( src, i );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
|
|
LinkReversedReachability();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseNodes
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseNodes( idLexer &src ) {
|
|
int numNodes, i;
|
|
aasNode_t node;
|
|
|
|
numNodes = src.ParseInt();
|
|
nodes.Resize( numNodes );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numNodes; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
node.planeNum = src.ParseInt();
|
|
node.children[0] = src.ParseInt();
|
|
node.children[1] = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
nodes.Append( node );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParsePortals
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParsePortals( idLexer &src ) {
|
|
int numPortals, i;
|
|
aasPortal_t portal;
|
|
|
|
numPortals = src.ParseInt();
|
|
portals.Resize( numPortals );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numPortals; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
portal.areaNum = src.ParseInt();
|
|
portal.clusters[0] = src.ParseInt();
|
|
portal.clusters[1] = src.ParseInt();
|
|
portal.clusterAreaNum[0] = src.ParseInt();
|
|
portal.clusterAreaNum[1] = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
portals.Append( portal );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ParseClusters
|
|
================
|
|
*/
|
|
bool idAASFileLocal::ParseClusters( idLexer &src ) {
|
|
int numClusters, i;
|
|
aasCluster_t cluster;
|
|
|
|
numClusters = src.ParseInt();
|
|
clusters.Resize( numClusters );
|
|
if ( !src.ExpectTokenString( "{" ) ) {
|
|
return false;
|
|
}
|
|
for ( i = 0; i < numClusters; i++ ) {
|
|
src.ParseInt();
|
|
src.ExpectTokenString( "(" );
|
|
cluster.numAreas = src.ParseInt();
|
|
cluster.numReachableAreas = src.ParseInt();
|
|
cluster.firstPortal = src.ParseInt();
|
|
cluster.numPortals = src.ParseInt();
|
|
src.ExpectTokenString( ")" );
|
|
clusters.Append( cluster );
|
|
}
|
|
if ( !src.ExpectTokenString( "}" ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::FinishAreas
|
|
================
|
|
*/
|
|
void idAASFileLocal::FinishAreas( void ) {
|
|
int i;
|
|
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
areas[i].center = AreaReachableGoal( i );
|
|
areas[i].bounds = AreaBounds( i );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::Load
|
|
================
|
|
*/
|
|
bool idAASFileLocal::Load( const idStr &fileName, unsigned int mapFileCRC ) {
|
|
idLexer src( LEXFL_NOFATALERRORS | LEXFL_NOSTRINGESCAPECHARS | LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWPATHNAMES );
|
|
idToken token;
|
|
int depth;
|
|
unsigned int c;
|
|
|
|
name = fileName;
|
|
crc = mapFileCRC;
|
|
|
|
common->Printf( "[Load AAS]\n" );
|
|
common->Printf( "loading %s\n", name.c_str() );
|
|
|
|
if ( !src.LoadFile( name ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( !src.ExpectTokenString( AAS_FILEID ) ) {
|
|
common->Warning( "Not an AAS file: '%s'", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
if ( !src.ReadToken( &token ) || token != AAS_FILEVERSION ) {
|
|
common->Warning( "AAS file '%s' has version %s instead of %s", name.c_str(), token.c_str(), AAS_FILEVERSION );
|
|
return false;
|
|
}
|
|
|
|
if ( !src.ExpectTokenType( TT_NUMBER, TT_INTEGER, &token ) ) {
|
|
common->Warning( "AAS file '%s' has no map file CRC", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
c = token.GetUnsignedLongValue();
|
|
if ( mapFileCRC && c != mapFileCRC ) {
|
|
common->Warning( "AAS file '%s' is out of date", name.c_str() );
|
|
return false;
|
|
}
|
|
|
|
// clear the file in memory
|
|
Clear();
|
|
|
|
// parse the file
|
|
while ( 1 ) {
|
|
if ( !src.ReadToken( &token ) ) {
|
|
break;
|
|
}
|
|
|
|
if ( token == "settings" ) {
|
|
if ( !settings.FromParser( src ) ) { return false; }
|
|
}
|
|
else if ( token == "planes" ) {
|
|
if ( !ParsePlanes( src ) ) { return false; }
|
|
}
|
|
else if ( token == "vertices" ) {
|
|
if ( !ParseVertices( src ) ) { return false; }
|
|
}
|
|
else if ( token == "edges" ) {
|
|
if ( !ParseEdges( src ) ) { return false; }
|
|
}
|
|
else if ( token == "edgeIndex" ) {
|
|
if ( !ParseIndex( src, edgeIndex ) ) { return false; }
|
|
}
|
|
else if ( token == "faces" ) {
|
|
if ( !ParseFaces( src ) ) { return false; }
|
|
}
|
|
else if ( token == "faceIndex" ) {
|
|
if ( !ParseIndex( src, faceIndex ) ) { return false; }
|
|
}
|
|
else if ( token == "areas" ) {
|
|
if ( !ParseAreas( src ) ) { return false; }
|
|
}
|
|
else if ( token == "nodes" ) {
|
|
if ( !ParseNodes( src ) ) { return false; }
|
|
}
|
|
else if ( token == "portals" ) {
|
|
if ( !ParsePortals( src ) ) { return false; }
|
|
}
|
|
else if ( token == "portalIndex" ) {
|
|
if ( !ParseIndex( src, portalIndex ) ) { return false; }
|
|
}
|
|
else if ( token == "clusters" ) {
|
|
if ( !ParseClusters( src ) ) { return false; }
|
|
}
|
|
else {
|
|
src.Error( "idAASFileLocal::Load: bad token \"%s\"", token.c_str() );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
FinishAreas();
|
|
|
|
depth = MaxTreeDepth();
|
|
if ( depth > MAX_AAS_TREE_DEPTH ) {
|
|
src.Error( "idAASFileLocal::Load: tree depth = %d", depth );
|
|
}
|
|
|
|
common->Printf( "done.\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::MemorySize
|
|
================
|
|
*/
|
|
int idAASFileLocal::MemorySize( void ) const {
|
|
int size;
|
|
|
|
size = planeList.Size();
|
|
size += vertices.Size();
|
|
size += edges.Size();
|
|
size += edgeIndex.Size();
|
|
size += faces.Size();
|
|
size += faceIndex.Size();
|
|
size += areas.Size();
|
|
size += nodes.Size();
|
|
size += portals.Size();
|
|
size += portalIndex.Size();
|
|
size += clusters.Size();
|
|
size += sizeof( idReachability_Walk ) * NumReachabilities();
|
|
|
|
return size;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::PrintInfo
|
|
================
|
|
*/
|
|
void idAASFileLocal::PrintInfo( void ) const {
|
|
common->Printf( "%6d KB file size\n", MemorySize() >> 10 );
|
|
common->Printf( "%6d areas\n", areas.Num() );
|
|
common->Printf( "%6d max tree depth\n", MaxTreeDepth() );
|
|
ReportRoutingEfficiency();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::NumReachabilities
|
|
================
|
|
*/
|
|
int idAASFileLocal::NumReachabilities( void ) const {
|
|
int i, num;
|
|
idReachability *reach;
|
|
|
|
num = 0;
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
for ( reach = areas[i].reach; reach; reach = reach->next ) {
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::ReportRoutingEfficiency
|
|
================
|
|
*/
|
|
void idAASFileLocal::ReportRoutingEfficiency( void ) const {
|
|
int numReachableAreas, total, i, n;
|
|
|
|
numReachableAreas = 0;
|
|
total = 0;
|
|
for ( i = 0; i < clusters.Num(); i++ ) {
|
|
n = clusters[i].numReachableAreas;
|
|
numReachableAreas += n;
|
|
total += n * n;
|
|
}
|
|
total += numReachableAreas * portals.Num();
|
|
|
|
common->Printf( "%6d reachable areas\n", numReachableAreas );
|
|
common->Printf( "%6d reachabilities\n", NumReachabilities() );
|
|
common->Printf( "%6d KB max routing cache\n", ( total * 3 ) >> 10 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::DeleteReachabilities
|
|
================
|
|
*/
|
|
void idAASFileLocal::DeleteReachabilities( void ) {
|
|
int i;
|
|
idReachability *reach, *nextReach;
|
|
|
|
for ( i = 0; i < areas.Num(); i++ ) {
|
|
for ( reach = areas[i].reach; reach; reach = nextReach ) {
|
|
nextReach = reach->next;
|
|
delete reach;
|
|
}
|
|
areas[i].reach = NULL;
|
|
areas[i].rev_reach = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAASFileLocal::DeleteClusters
|
|
================
|
|
*/
|
|
void idAASFileLocal::DeleteClusters( void ) {
|
|
aasPortal_t portal;
|
|
aasCluster_t cluster;
|
|
|
|
portals.Clear();
|
|
portalIndex.Clear();
|
|
clusters.Clear();
|
|
|
|
// first portal is a dummy
|
|
memset( &portal, 0, sizeof( portal ) );
|
|
portals.Append( portal );
|
|
|
|
// first cluster is a dummy
|
|
memset( &cluster, 0, sizeof( portal ) );
|
|
clusters.Append( cluster );
|
|
}
|