mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-11 13:30:59 +00:00
736ec20d4d
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.
966 lines
24 KiB
C++
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;
|
|
}
|