mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
1125 lines
24 KiB
C++
1125 lines
24 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition 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 BFG Edition 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 "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
/*
|
|
===============
|
|
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;
|
|
const unsigned char* ptr;
|
|
|
|
crc = 0;
|
|
ptr = reinterpret_cast<const unsigned char*>( str );
|
|
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( TAG_IDLIB ) 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->SetTexCoord( v[3], 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" );
|
|
idVec2 st;
|
|
for( i = 0; i < GetWidth(); i++ )
|
|
{
|
|
fp->WriteFloatString( " ( " );
|
|
for( j = 0; j < GetHeight(); j++ )
|
|
{
|
|
v = &verts[ j * GetWidth() + i ];
|
|
st = v->GetTexCoord();
|
|
fp->WriteFloatString( " ( %f %f %f %f %f )", v->xyz[0] + origin[0],
|
|
v->xyz[1] + origin[1], v->xyz[2] + origin[2], st[0], st[1] );
|
|
}
|
|
fp->WriteFloatString( " )\n" );
|
|
}
|
|
fp->WriteFloatString( " )\n }\n}\n" );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idMapPatch::GetGeometryCRC
|
|
===============
|
|
*/
|
|
unsigned int idMapPatch::GetGeometryCRC() 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( TAG_IDLIB ) 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( TAG_IDLIB ) 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, shift[2], rotate;
|
|
float scale[2];
|
|
idVec3 planepts[3];
|
|
idToken token;
|
|
idList<idMapBrushSide*> sides;
|
|
idMapBrushSide* side;
|
|
idDict epairs;
|
|
|
|
do
|
|
{
|
|
if( src.CheckTokenString( "}" ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
side = new( TAG_IDLIB ) 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;
|
|
|
|
// read the texture shift, rotate and scale
|
|
shift[0] = src.ParseInt();
|
|
shift[1] = src.ParseInt();
|
|
rotate = src.ParseInt();
|
|
scale[0] = src.ParseFloat();
|
|
scale[1] = 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( TAG_IDLIB ) 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() 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( TAG_IDLIB ) 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() 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_basepath" );
|
|
}
|
|
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()
|
|
{
|
|
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 = FILE_NOT_FOUND_TIMESTAMP;
|
|
if( idLib::fileSystem->ReadFile( name, NULL, &time ) > 0 )
|
|
{
|
|
return ( time > fileTime );
|
|
}
|
|
}
|
|
return true;
|
|
}
|