dhewm3/neo/idlib/MapFile.cpp
dhewg 736ec20d4d Untangle the epic precompiled.h mess
Don't include the lazy precompiled.h everywhere, only what's
required for the compilation unit.
platform.h needs to be included instead to provide all essential
defines and types.
All includes use the relative path to the neo or the game
specific root.
Move all idlib related includes from idlib/Lib.h to precompiled.h.
precompiled.h still exists for the MFC stuff in tools/.
Add some missing header guards.
2011-12-19 23:21:47 +01:00

966 lines
24 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 "sys/platform.h"
#include "framework/File.h"
#include "framework/FileSystem.h"
#include "idlib/MapFile.h"
/*
===============
FloatCRC
===============
*/
ID_INLINE unsigned int FloatCRC( float f ) {
return *(unsigned int *)&f;
}
/*
===============
StringCRC
===============
*/
ID_INLINE unsigned int StringCRC( const char *str ) {
unsigned int i, crc;
crc = 0;
for ( i = 0; str[i]; i++ ) {
crc ^= str[i] << (i & 3);
}
return crc;
}
/*
=================
ComputeAxisBase
WARNING : special case behaviour of atan2(y,x) <-> atan(y/x) might not be the same everywhere when x == 0
rotation by (0,RotY,RotZ) assigns X to normal
=================
*/
static void ComputeAxisBase( const idVec3 &normal, idVec3 &texS, idVec3 &texT ) {
float RotY, RotZ;
idVec3 n;
// do some cleaning
n[0] = ( idMath::Fabs( normal[0] ) < 1e-6f ) ? 0.0f : normal[0];
n[1] = ( idMath::Fabs( normal[1] ) < 1e-6f ) ? 0.0f : normal[1];
n[2] = ( idMath::Fabs( normal[2] ) < 1e-6f ) ? 0.0f : normal[2];
RotY = -atan2( n[2], idMath::Sqrt( n[1] * n[1] + n[0] * n[0]) );
RotZ = atan2( n[1], n[0] );
// rotate (0,1,0) and (0,0,1) to compute texS and texT
texS[0] = -sin(RotZ);
texS[1] = cos(RotZ);
texS[2] = 0;
// the texT vector is along -Z ( T texture coorinates axis )
texT[0] = -sin(RotY) * cos(RotZ);
texT[1] = -sin(RotY) * sin(RotZ);
texT[2] = -cos(RotY);
}
/*
=================
idMapBrushSide::GetTextureVectors
=================
*/
void idMapBrushSide::GetTextureVectors( idVec4 v[2] ) const {
int i;
idVec3 texX, texY;
ComputeAxisBase( plane.Normal(), texX, texY );
for ( i = 0; i < 2; i++ ) {
v[i][0] = texX[0] * texMat[i][0] + texY[0] * texMat[i][1];
v[i][1] = texX[1] * texMat[i][0] + texY[1] * texMat[i][1];
v[i][2] = texX[2] * texMat[i][0] + texY[2] * texMat[i][1];
v[i][3] = texMat[i][2] + ( origin * v[i].ToVec3() );
}
}
/*
=================
idMapPatch::Parse
=================
*/
idMapPatch *idMapPatch::Parse( idLexer &src, const idVec3 &origin, bool patchDef3, float version ) {
float info[7];
idDrawVert *vert;
idToken token;
int i, j;
if ( !src.ExpectTokenString( "{" ) ) {
return NULL;
}
// read the material (we had an implicit 'textures/' in the old format...)
if ( !src.ReadToken( &token ) ) {
src.Error( "idMapPatch::Parse: unexpected EOF" );
return NULL;
}
// Parse it
if (patchDef3) {
if ( !src.Parse1DMatrix( 7, info ) ) {
src.Error( "idMapPatch::Parse: unable to Parse patchDef3 info" );
return NULL;
}
} else {
if ( !src.Parse1DMatrix( 5, info ) ) {
src.Error( "idMapPatch::Parse: unable to parse patchDef2 info" );
return NULL;
}
}
idMapPatch *patch = new idMapPatch( info[0], info[1] );
patch->SetSize( info[0], info[1] );
if ( version < 2.0f ) {
patch->SetMaterial( "textures/" + token );
} else {
patch->SetMaterial( token );
}
if ( patchDef3 ) {
patch->SetHorzSubdivisions( info[2] );
patch->SetVertSubdivisions( info[3] );
patch->SetExplicitlySubdivided( true );
}
if ( patch->GetWidth() < 0 || patch->GetHeight() < 0 ) {
src.Error( "idMapPatch::Parse: bad size" );
delete patch;
return NULL;
}
// these were written out in the wrong order, IMHO
if ( !src.ExpectTokenString( "(" ) ) {
src.Error( "idMapPatch::Parse: bad patch vertex data" );
delete patch;
return NULL;
}
for ( j = 0; j < patch->GetWidth(); j++ ) {
if ( !src.ExpectTokenString( "(" ) ) {
src.Error( "idMapPatch::Parse: bad vertex row data" );
delete patch;
return NULL;
}
for ( i = 0; i < patch->GetHeight(); i++ ) {
float v[5];
if ( !src.Parse1DMatrix( 5, v ) ) {
src.Error( "idMapPatch::Parse: bad vertex column data" );
delete patch;
return NULL;
}
vert = &((*patch)[i * patch->GetWidth() + j]);
vert->xyz[0] = v[0] - origin[0];
vert->xyz[1] = v[1] - origin[1];
vert->xyz[2] = v[2] - origin[2];
vert->st[0] = v[3];
vert->st[1] = v[4];
}
if ( !src.ExpectTokenString( ")" ) ) {
delete patch;
src.Error( "idMapPatch::Parse: unable to parse patch control points" );
return NULL;
}
}
if ( !src.ExpectTokenString( ")" ) ) {
src.Error( "idMapPatch::Parse: unable to parse patch control points, no closure" );
delete patch;
return NULL;
}
// read any key/value pairs
while( src.ReadToken( &token ) ) {
if ( token == "}" ) {
src.ExpectTokenString( "}" );
break;
}
if ( token.type == TT_STRING ) {
idStr key = token;
src.ExpectTokenType( TT_STRING, 0, &token );
patch->epairs.Set( key, token );
}
}
return patch;
}
/*
============
idMapPatch::Write
============
*/
bool idMapPatch::Write( idFile *fp, int primitiveNum, const idVec3 &origin ) const {
int i, j;
const idDrawVert *v;
if ( GetExplicitlySubdivided() ) {
fp->WriteFloatString( "// primitive %d\n{\n patchDef3\n {\n", primitiveNum );
fp->WriteFloatString( " \"%s\"\n ( %d %d %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight(), GetHorzSubdivisions(), GetVertSubdivisions());
} else {
fp->WriteFloatString( "// primitive %d\n{\n patchDef2\n {\n", primitiveNum );
fp->WriteFloatString( " \"%s\"\n ( %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight());
}
fp->WriteFloatString( " (\n" );
for ( i = 0; i < GetWidth(); i++ ) {
fp->WriteFloatString( " ( " );
for ( j = 0; j < GetHeight(); j++ ) {
v = &verts[ j * GetWidth() + i ];
fp->WriteFloatString( " ( %f %f %f %f %f )", v->xyz[0] + origin[0],
v->xyz[1] + origin[1], v->xyz[2] + origin[2], v->st[0], v->st[1] );
}
fp->WriteFloatString( " )\n" );
}
fp->WriteFloatString( " )\n }\n}\n" );
return true;
}
/*
===============
idMapPatch::GetGeometryCRC
===============
*/
unsigned int idMapPatch::GetGeometryCRC( void ) const {
int i, j;
unsigned int crc;
crc = GetHorzSubdivisions() ^ GetVertSubdivisions();
for ( i = 0; i < GetWidth(); i++ ) {
for ( j = 0; j < GetHeight(); j++ ) {
crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.x );
crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.y );
crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.z );
}
}
crc ^= StringCRC( GetMaterial() );
return crc;
}
/*
=================
idMapBrush::Parse
=================
*/
idMapBrush *idMapBrush::Parse( idLexer &src, const idVec3 &origin, bool newFormat, float version ) {
int i;
idVec3 planepts[3];
idToken token;
idList<idMapBrushSide*> sides;
idMapBrushSide *side;
idDict epairs;
if ( !src.ExpectTokenString( "{" ) ) {
return NULL;
}
do {
if ( !src.ReadToken( &token ) ) {
src.Error( "idMapBrush::Parse: unexpected EOF" );
sides.DeleteContents( true );
return NULL;
}
if ( token == "}" ) {
break;
}
// here we may have to jump over brush epairs ( only used in editor )
do {
// if token is a brace
if ( token == "(" ) {
break;
}
// the token should be a key string for a key/value pair
if ( token.type != TT_STRING ) {
src.Error( "idMapBrush::Parse: unexpected %s, expected ( or epair key string", token.c_str() );
sides.DeleteContents( true );
return NULL;
}
idStr key = token;
if ( !src.ReadTokenOnLine( &token ) || token.type != TT_STRING ) {
src.Error( "idMapBrush::Parse: expected epair value string not found" );
sides.DeleteContents( true );
return NULL;
}
epairs.Set( key, token );
// try to read the next key
if ( !src.ReadToken( &token ) ) {
src.Error( "idMapBrush::Parse: unexpected EOF" );
sides.DeleteContents( true );
return NULL;
}
} while (1);
src.UnreadToken( &token );
side = new idMapBrushSide();
sides.Append(side);
if ( newFormat ) {
if ( !src.Parse1DMatrix( 4, side->plane.ToFloatPtr() ) ) {
src.Error( "idMapBrush::Parse: unable to read brush side plane definition" );
sides.DeleteContents( true );
return NULL;
}
} else {
// read the three point plane definition
if (!src.Parse1DMatrix( 3, planepts[0].ToFloatPtr() ) ||
!src.Parse1DMatrix( 3, planepts[1].ToFloatPtr() ) ||
!src.Parse1DMatrix( 3, planepts[2].ToFloatPtr() ) ) {
src.Error( "idMapBrush::Parse: unable to read brush side plane definition" );
sides.DeleteContents( true );
return NULL;
}
planepts[0] -= origin;
planepts[1] -= origin;
planepts[2] -= origin;
side->plane.FromPoints( planepts[0], planepts[1], planepts[2] );
}
// read the texture matrix
// this is odd, because the texmat is 2D relative to default planar texture axis
if ( !src.Parse2DMatrix( 2, 3, side->texMat[0].ToFloatPtr() ) ) {
src.Error( "idMapBrush::Parse: unable to read brush side texture matrix" );
sides.DeleteContents( true );
return NULL;
}
side->origin = origin;
// read the material
if ( !src.ReadTokenOnLine( &token ) ) {
src.Error( "idMapBrush::Parse: unable to read brush side material" );
sides.DeleteContents( true );
return NULL;
}
// we had an implicit 'textures/' in the old format...
if ( version < 2.0f ) {
side->material = "textures/" + token;
} else {
side->material = token;
}
// Q2 allowed override of default flags and values, but we don't any more
if ( src.ReadTokenOnLine( &token ) ) {
if ( src.ReadTokenOnLine( &token ) ) {
if ( src.ReadTokenOnLine( &token ) ) {
}
}
}
} while( 1 );
if ( !src.ExpectTokenString( "}" ) ) {
sides.DeleteContents( true );
return NULL;
}
idMapBrush *brush = new idMapBrush();
for ( i = 0; i < sides.Num(); i++ ) {
brush->AddSide( sides[i] );
}
brush->epairs = epairs;
return brush;
}
/*
=================
idMapBrush::ParseQ3
=================
*/
idMapBrush *idMapBrush::ParseQ3( idLexer &src, const idVec3 &origin ) {
int i;
idVec3 planepts[3];
idToken token;
idList<idMapBrushSide*> sides;
idMapBrushSide *side;
idDict epairs;
do {
if ( src.CheckTokenString( "}" ) ) {
break;
}
side = new idMapBrushSide();
sides.Append( side );
// read the three point plane definition
if (!src.Parse1DMatrix( 3, planepts[0].ToFloatPtr() ) ||
!src.Parse1DMatrix( 3, planepts[1].ToFloatPtr() ) ||
!src.Parse1DMatrix( 3, planepts[2].ToFloatPtr() ) ) {
src.Error( "idMapBrush::ParseQ3: unable to read brush side plane definition" );
sides.DeleteContents( true );
return NULL;
}
planepts[0] -= origin;
planepts[1] -= origin;
planepts[2] -= origin;
side->plane.FromPoints( planepts[0], planepts[1], planepts[2] );
// read the material
if ( !src.ReadTokenOnLine( &token ) ) {
src.Error( "idMapBrush::ParseQ3: unable to read brush side material" );
sides.DeleteContents( true );
return NULL;
}
// we have an implicit 'textures/' in the old format
side->material = "textures/" + token;
// skip the texture shift, rotate and scale
src.ParseInt();
src.ParseInt();
src.ParseInt();
src.ParseFloat();
src.ParseFloat();
side->texMat[0] = idVec3( 0.03125f, 0.0f, 0.0f );
side->texMat[1] = idVec3( 0.0f, 0.03125f, 0.0f );
side->origin = origin;
// Q2 allowed override of default flags and values, but we don't any more
if ( src.ReadTokenOnLine( &token ) ) {
if ( src.ReadTokenOnLine( &token ) ) {
if ( src.ReadTokenOnLine( &token ) ) {
}
}
}
} while( 1 );
idMapBrush *brush = new idMapBrush();
for ( i = 0; i < sides.Num(); i++ ) {
brush->AddSide( sides[i] );
}
brush->epairs = epairs;
return brush;
}
/*
============
idMapBrush::Write
============
*/
bool idMapBrush::Write( idFile *fp, int primitiveNum, const idVec3 &origin ) const {
int i;
idMapBrushSide *side;
fp->WriteFloatString( "// primitive %d\n{\n brushDef3\n {\n", primitiveNum );
// write brush epairs
for ( i = 0; i < epairs.GetNumKeyVals(); i++) {
fp->WriteFloatString( " \"%s\" \"%s\"\n", epairs.GetKeyVal(i)->GetKey().c_str(), epairs.GetKeyVal(i)->GetValue().c_str());
}
// write brush sides
for ( i = 0; i < GetNumSides(); i++ ) {
side = GetSide( i );
fp->WriteFloatString( " ( %f %f %f %f ) ", side->plane[0], side->plane[1], side->plane[2], side->plane[3] );
fp->WriteFloatString( "( ( %f %f %f ) ( %f %f %f ) ) \"%s\" 0 0 0\n",
side->texMat[0][0], side->texMat[0][1], side->texMat[0][2],
side->texMat[1][0], side->texMat[1][1], side->texMat[1][2],
side->material.c_str() );
}
fp->WriteFloatString( " }\n}\n" );
return true;
}
/*
===============
idMapBrush::GetGeometryCRC
===============
*/
unsigned int idMapBrush::GetGeometryCRC( void ) const {
int i, j;
idMapBrushSide *mapSide;
unsigned int crc;
crc = 0;
for ( i = 0; i < GetNumSides(); i++ ) {
mapSide = GetSide(i);
for ( j = 0; j < 4; j++ ) {
crc ^= FloatCRC( mapSide->GetPlane()[j] );
}
crc ^= StringCRC( mapSide->GetMaterial() );
}
return crc;
}
/*
================
idMapEntity::Parse
================
*/
idMapEntity *idMapEntity::Parse( idLexer &src, bool worldSpawn, float version ) {
idToken token;
idMapEntity *mapEnt;
idMapPatch *mapPatch;
idMapBrush *mapBrush;
bool worldent;
idVec3 origin;
double v1, v2, v3;
if ( !src.ReadToken(&token) ) {
return NULL;
}
if ( token != "{" ) {
src.Error( "idMapEntity::Parse: { not found, found %s", token.c_str() );
return NULL;
}
mapEnt = new idMapEntity();
if ( worldSpawn ) {
mapEnt->primitives.Resize( 1024, 256 );
}
origin.Zero();
worldent = false;
do {
if ( !src.ReadToken(&token) ) {
src.Error( "idMapEntity::Parse: EOF without closing brace" );
return NULL;
}
if ( token == "}" ) {
break;
}
if ( token == "{" ) {
// parse a brush or patch
if ( !src.ReadToken( &token ) ) {
src.Error( "idMapEntity::Parse: unexpected EOF" );
return NULL;
}
if ( worldent ) {
origin.Zero();
}
// if is it a brush: brush, brushDef, brushDef2, brushDef3
if ( token.Icmpn( "brush", 5 ) == 0 ) {
mapBrush = idMapBrush::Parse( src, origin, ( !token.Icmp( "brushDef2" ) || !token.Icmp( "brushDef3" ) ), version );
if ( !mapBrush ) {
return NULL;
}
mapEnt->AddPrimitive( mapBrush );
}
// if is it a patch: patchDef2, patchDef3
else if ( token.Icmpn( "patch", 5 ) == 0 ) {
mapPatch = idMapPatch::Parse( src, origin, !token.Icmp( "patchDef3" ), version );
if ( !mapPatch ) {
return NULL;
}
mapEnt->AddPrimitive( mapPatch );
}
// assume it's a brush in Q3 or older style
else {
src.UnreadToken( &token );
mapBrush = idMapBrush::ParseQ3( src, origin );
if ( !mapBrush ) {
return NULL;
}
mapEnt->AddPrimitive( mapBrush );
}
} else {
idStr key, value;
// parse a key / value pair
key = token;
src.ReadTokenOnLine( &token );
value = token;
// strip trailing spaces that sometimes get accidentally
// added in the editor
value.StripTrailingWhitespace();
key.StripTrailingWhitespace();
mapEnt->epairs.Set( key, value );
if ( !idStr::Icmp( key, "origin" ) ) {
// scanf into doubles, then assign, so it is idVec size independent
v1 = v2 = v3 = 0;
sscanf( value, "%lf %lf %lf", &v1, &v2, &v3 );
origin.x = v1;
origin.y = v2;
origin.z = v3;
}
else if ( !idStr::Icmp( key, "classname" ) && !idStr::Icmp( value, "worldspawn" ) ) {
worldent = true;
}
}
} while( 1 );
return mapEnt;
}
/*
============
idMapEntity::Write
============
*/
bool idMapEntity::Write( idFile *fp, int entityNum ) const {
int i;
idMapPrimitive *mapPrim;
idVec3 origin;
fp->WriteFloatString( "// entity %d\n{\n", entityNum );
// write entity epairs
for ( i = 0; i < epairs.GetNumKeyVals(); i++) {
fp->WriteFloatString( "\"%s\" \"%s\"\n", epairs.GetKeyVal(i)->GetKey().c_str(), epairs.GetKeyVal(i)->GetValue().c_str());
}
epairs.GetVector( "origin", "0 0 0", origin );
// write pritimives
for ( i = 0; i < GetNumPrimitives(); i++ ) {
mapPrim = GetPrimitive( i );
switch( mapPrim->GetType() ) {
case idMapPrimitive::TYPE_BRUSH:
static_cast<idMapBrush*>(mapPrim)->Write( fp, i, origin );
break;
case idMapPrimitive::TYPE_PATCH:
static_cast<idMapPatch*>(mapPrim)->Write( fp, i, origin );
break;
}
}
fp->WriteFloatString( "}\n" );
return true;
}
/*
===============
idMapEntity::RemovePrimitiveData
===============
*/
void idMapEntity::RemovePrimitiveData() {
primitives.DeleteContents(true);
}
/*
===============
idMapEntity::GetGeometryCRC
===============
*/
unsigned int idMapEntity::GetGeometryCRC( void ) const {
int i;
unsigned int crc;
idMapPrimitive *mapPrim;
crc = 0;
for ( i = 0; i < GetNumPrimitives(); i++ ) {
mapPrim = GetPrimitive( i );
switch( mapPrim->GetType() ) {
case idMapPrimitive::TYPE_BRUSH:
crc ^= static_cast<idMapBrush*>(mapPrim)->GetGeometryCRC();
break;
case idMapPrimitive::TYPE_PATCH:
crc ^= static_cast<idMapPatch*>(mapPrim)->GetGeometryCRC();
break;
}
}
return crc;
}
/*
===============
idMapFile::Parse
===============
*/
bool idMapFile::Parse( const char *filename, bool ignoreRegion, bool osPath ) {
// no string concatenation for epairs and allow path names for materials
idLexer src( LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES );
idToken token;
idStr fullName;
idMapEntity *mapEnt;
int i, j, k;
name = filename;
name.StripFileExtension();
fullName = name;
hasPrimitiveData = false;
if ( !ignoreRegion ) {
// try loading a .reg file first
fullName.SetFileExtension( "reg" );
src.LoadFile( fullName, osPath );
}
if ( !src.IsLoaded() ) {
// now try a .map file
fullName.SetFileExtension( "map" );
src.LoadFile( fullName, osPath );
if ( !src.IsLoaded() ) {
// didn't get anything at all
return false;
}
}
version = OLD_MAP_VERSION;
fileTime = src.GetFileTime();
entities.DeleteContents( true );
if ( src.CheckTokenString( "Version" ) ) {
src.ReadTokenOnLine( &token );
version = token.GetFloatValue();
}
while( 1 ) {
mapEnt = idMapEntity::Parse( src, ( entities.Num() == 0 ), version );
if ( !mapEnt ) {
break;
}
entities.Append( mapEnt );
}
SetGeometryCRC();
// if the map has a worldspawn
if ( entities.Num() ) {
// "removeEntities" "classname" can be set in the worldspawn to remove all entities with the given classname
const idKeyValue *removeEntities = entities[0]->epairs.MatchPrefix( "removeEntities", NULL );
while ( removeEntities ) {
RemoveEntities( removeEntities->GetValue() );
removeEntities = entities[0]->epairs.MatchPrefix( "removeEntities", removeEntities );
}
// "overrideMaterial" "material" can be set in the worldspawn to reset all materials
idStr material;
if ( entities[0]->epairs.GetString( "overrideMaterial", "", material ) ) {
for ( i = 0; i < entities.Num(); i++ ) {
mapEnt = entities[i];
for ( j = 0; j < mapEnt->GetNumPrimitives(); j++ ) {
idMapPrimitive *mapPrimitive = mapEnt->GetPrimitive( j );
switch( mapPrimitive->GetType() ) {
case idMapPrimitive::TYPE_BRUSH: {
idMapBrush *mapBrush = static_cast<idMapBrush *>(mapPrimitive);
for ( k = 0; k < mapBrush->GetNumSides(); k++ ) {
mapBrush->GetSide( k )->SetMaterial( material );
}
break;
}
case idMapPrimitive::TYPE_PATCH: {
static_cast<idMapPatch *>(mapPrimitive)->SetMaterial( material );
break;
}
}
}
}
}
// force all entities to have a name key/value pair
if ( entities[0]->epairs.GetBool( "forceEntityNames" ) ) {
for ( i = 1; i < entities.Num(); i++ ) {
mapEnt = entities[i];
if ( !mapEnt->epairs.FindKey( "name" ) ) {
mapEnt->epairs.Set( "name", va( "%s%d", mapEnt->epairs.GetString( "classname", "forcedName" ), i ) );
}
}
}
// move the primitives of any func_group entities to the worldspawn
if ( entities[0]->epairs.GetBool( "moveFuncGroups" ) ) {
for ( i = 1; i < entities.Num(); i++ ) {
mapEnt = entities[i];
if ( idStr::Icmp( mapEnt->epairs.GetString( "classname" ), "func_group" ) == 0 ) {
entities[0]->primitives.Append( mapEnt->primitives );
mapEnt->primitives.Clear();
}
}
}
}
hasPrimitiveData = true;
return true;
}
/*
============
idMapFile::Write
============
*/
bool idMapFile::Write( const char *fileName, const char *ext, bool fromBasePath ) {
int i;
idStr qpath;
idFile *fp;
qpath = fileName;
qpath.SetFileExtension( ext );
idLib::common->Printf( "writing %s...\n", qpath.c_str() );
if ( fromBasePath ) {
fp = idLib::fileSystem->OpenFileWrite( qpath, "fs_devpath" );
}
else {
fp = idLib::fileSystem->OpenExplicitFileWrite( qpath );
}
if ( !fp ) {
idLib::common->Warning( "Couldn't open %s\n", qpath.c_str() );
return false;
}
fp->WriteFloatString( "Version %f\n", (float) CURRENT_MAP_VERSION );
for ( i = 0; i < entities.Num(); i++ ) {
entities[i]->Write( fp, i );
}
idLib::fileSystem->CloseFile( fp );
return true;
}
/*
===============
idMapFile::SetGeometryCRC
===============
*/
void idMapFile::SetGeometryCRC( void ) {
int i;
geometryCRC = 0;
for ( i = 0; i < entities.Num(); i++ ) {
geometryCRC ^= entities[i]->GetGeometryCRC();
}
}
/*
===============
idMapFile::AddEntity
===============
*/
int idMapFile::AddEntity( idMapEntity *mapEnt ) {
int ret = entities.Append( mapEnt );
return ret;
}
/*
===============
idMapFile::FindEntity
===============
*/
idMapEntity *idMapFile::FindEntity( const char *name ) {
for ( int i = 0; i < entities.Num(); i++ ) {
idMapEntity *ent = entities[i];
if ( idStr::Icmp( ent->epairs.GetString( "name" ), name ) == 0 ) {
return ent;
}
}
return NULL;
}
/*
===============
idMapFile::RemoveEntity
===============
*/
void idMapFile::RemoveEntity( idMapEntity *mapEnt ) {
entities.Remove( mapEnt );
delete mapEnt;
}
/*
===============
idMapFile::RemoveEntity
===============
*/
void idMapFile::RemoveEntities( const char *classname ) {
for ( int i = 0; i < entities.Num(); i++ ) {
idMapEntity *ent = entities[i];
if ( idStr::Icmp( ent->epairs.GetString( "classname" ), classname ) == 0 ) {
delete entities[i];
entities.RemoveIndex( i );
i--;
}
}
}
/*
===============
idMapFile::RemoveAllEntities
===============
*/
void idMapFile::RemoveAllEntities() {
entities.DeleteContents( true );
hasPrimitiveData = false;
}
/*
===============
idMapFile::RemovePrimitiveData
===============
*/
void idMapFile::RemovePrimitiveData() {
for ( int i = 0; i < entities.Num(); i++ ) {
idMapEntity *ent = entities[i];
ent->RemovePrimitiveData();
}
hasPrimitiveData = false;
}
/*
===============
idMapFile::NeedsReload
===============
*/
bool idMapFile::NeedsReload() {
if ( name.Length() ) {
ID_TIME_T time = (ID_TIME_T)-1;
if ( idLib::fileSystem->ReadFile( name, NULL, &time ) > 0 ) {
return ( time > fileTime );
}
}
return true;
}