d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 29985681a1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '29985681a1'
${ noResults }
source-engine/hammer/loadsave_map.cpp

1200 lines
26 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "stdafx.h"
#include <io.h>
#include "hammer.h"
#include "GlobalFunctions.h"
#include "MapErrorsDlg.h"
#include "Options.h"
#include "MapDoc.h"
#include "MapEntity.h"
#include "MapFace.h"
#include "MapGroup.h"
#include "MapSolid.h"
#include "MapStudioModel.h"
#include "MapWorld.h"
#include "progdlg.h"
#include "TextureSystem.h"
#include "MapDisp.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#pragma optimize("g", off)
#pragma warning(disable: 4748) // buffer overrung with optimizations off - remove if we turn "g" back on
#define TEXTURE_NAME_LEN 128
// All files are opened in binary, and we want to save CR/LF
#define ENDLINE "\r\n"
enum
{
fileOsError = -1, // big error!
fileError = -2, // problem
fileOk = -3, // loaded ok
fileDone = -4 // got not-my-kind of line
};
BOOL bSaveVisiblesOnly;
static BOOL bErrors;
static int nInvalidSolids;
static CProgressDlg *pProgDlg;
static MAPFORMAT MapFormat;
static BOOL bStuffed;
static char szStuffed[255];
static UINT uMapVersion = 0;
//-----------------------------------------------------------------------------
// Purpose:
// Input : buf -
//-----------------------------------------------------------------------------
static void StuffLine(char * buf)
{
Assert(!bStuffed);
V_strcpy_safe(szStuffed, buf);
bStuffed = TRUE;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// buf -
//-----------------------------------------------------------------------------
static void GetLine(std::fstream& file, char *buf)
{
if(bStuffed)
{
if(buf)
strcpy(buf, szStuffed);
bStuffed = FALSE;
return;
}
char szBuf[1024];
while(1)
{
file >> std::ws;
file.getline(szBuf, 512);
if(file.eof())
return;
if(!strncmp(szBuf, "//", 2))
continue;
file >> std::ws;
if(buf)
{
// char *p = strchr(szBuf, '\n');
// if(p) p[0] = 0;
// p = strchr(szBuf, '\r');
// if(p) p[0] = 0;
strcpy(buf, szBuf);
}
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pObject -
// file -
// pIntersecting -
// Output : int
//-----------------------------------------------------------------------------
static int SaveSolidChildrenOf(CMapClass *pObject, std::fstream& file, BoundBox *pIntersecting = NULL)
{
CMapWorld *pWorld = (CMapWorld*) CMapClass::GetWorldObject(pObject);
//
// If we are only saving visible objects and this object isn't visible, don't save it.
//
if (bSaveVisiblesOnly && (pObject != pWorld) && !pObject->IsVisible())
{
return fileOk; // not an error - return ok
}
//
// If we are only saving objects within a particular bounding box and this object isn't, don't save it.
//
if (pIntersecting && !pObject->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
{
return fileOk;
}
const CMapObjectList *pChildren = pObject->GetChildren();
FOR_EACH_OBJ( *pChildren, pos )
{
int iRvl = -1;
CMapClass *pChild = pChildren->Element(pos);
if (!pIntersecting || pChild->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
{
if (pChild->IsMapClass(MAPCLASS_TYPE(CMapSolid)))
{
if (!bSaveVisiblesOnly || pChild->IsVisible())
{
iRvl = pChild->SerializeMAP(file, TRUE);
}
}
else if (pChild->IsMapClass(MAPCLASS_TYPE(CMapGroup)))
{
iRvl = SaveSolidChildrenOf(pChild, file, pIntersecting);
}
// return error if there is an error
if (iRvl != -1 && iRvl != fileOk)
{
return iRvl;
}
}
}
return fileOk; // ok.
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pObject -
// file -
// pIntersecting -
// Output : int
//-----------------------------------------------------------------------------
static int SaveEntityChildrenOf(CMapClass *pObject, std::fstream& file, BoundBox *pIntersecting)
{
CMapWorld *pWorld = (CMapWorld *)CMapClass::GetWorldObject(pObject);
if (bSaveVisiblesOnly && pObject != pWorld && !pObject->IsVisible())
{
return fileOk; // no error
}
if (pIntersecting && !pObject->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
{
return fileOk;
}
const CMapObjectList *pChildren = pObject->GetChildren();
FOR_EACH_OBJ( *pChildren, pos )
{
int iRvl = -1;
CMapClass *pChild = pChildren->Element(pos);
if (!pIntersecting || pChild->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
{
if (pChild->IsMapClass(MAPCLASS_TYPE(CMapEntity)))
{
if (!bSaveVisiblesOnly || pChild->IsVisible())
{
iRvl = pChild->SerializeMAP(file, TRUE);
}
}
else if (pChild->IsMapClass(MAPCLASS_TYPE(CMapGroup)))
{
iRvl = SaveEntityChildrenOf(pChild, file, pIntersecting);
}
// return error if there is an error
if (iRvl != -1 && iRvl != fileOk)
{
return iRvl;
}
}
}
return fileOk; // ok.
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
// file -
// Output : int
//-----------------------------------------------------------------------------
static int ReadSolids(CMapClass *pObject, std::fstream& file)
{
int nSolids = 0;
char szBuf[128];
while(1)
{
GetLine(file, szBuf);
if(szBuf[0] != '{')
{
StuffLine(szBuf);
break;
}
CMapSolid *pSolid = new CMapSolid;
int iRvl = pSolid->SerializeMAP(file, FALSE);
if(iRvl == fileError)
{
// delete the solid
delete pSolid;
++nInvalidSolids;
}
else if(iRvl == fileOsError)
{
// big problem
delete pSolid;
return fileOsError;
}
else
pObject->AddChild(pSolid);
++nSolids;
}
return nSolids;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// Output : int
//-----------------------------------------------------------------------------
static int PeekChar(std::fstream& file)
{
if(bStuffed) // stuffed.. return first char
return szStuffed[0];
char szBuf[1024];
szBuf[0] = 0;
// get next line
GetLine(file, szBuf);
// still blank? return eof
if(szBuf[0] == 0)
return EOF;
// to get it next call to getline
StuffLine(szBuf);
return szBuf[0];
}
//-----------------------------------------------------------------------------
// Purpose: Sets the MAP format for saving.
// Input : mf - MAP format to use when saving.
//-----------------------------------------------------------------------------
void SetMapFormat(MAPFORMAT mf)
{
Assert((mf == mfHalfLife) || (mf == mfHalfLife2));
MapFormat = mf;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int CMapClass::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
// no info stored in MAPs ..
return fileOk;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int CMapFace::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
char szBuf[512];
if (fIsStoring)
{
char *pszTexture;
char szTexture[sizeof(texture.texture)+1];
szTexture[sizeof(texture.texture)] = 0;
memcpy(szTexture, texture.texture, sizeof texture.texture);
strlwr(szTexture);
if (MapFormat == mfQuake2)
{
pszTexture = strstr(szTexture, ".");
if (pszTexture)
{
*pszTexture = 0;
}
pszTexture = strstr(szTexture, "textures\\");
if (pszTexture == NULL)
{
pszTexture = szTexture;
}
else
{
pszTexture += strlen("textures\\");
}
}
else
{
pszTexture = szTexture;
}
strupr(szTexture);
//
// Reverse the slashes -- thank you id.
//
for (int i = strlen(pszTexture) - 1; i >= 0; i--)
{
if (pszTexture[i] == '\\')
pszTexture[i] = '/';
}
//
// Convert the plane points to integers.
//
for (int nPlane = 0; nPlane < 3; nPlane++)
{
plane.planepts[nPlane][0] = V_rint(plane.planepts[nPlane][0]);
plane.planepts[nPlane][1] = V_rint(plane.planepts[nPlane][1]);
plane.planepts[nPlane][2] = V_rint(plane.planepts[nPlane][2]);
}
//
// Check for duplicate plane points. All three plane points must be unique
// or it isn't a valid plane. Try to fix it if it isn't valid.
//
if (!CheckFace())
{
Fix();
}
sprintf(szBuf,
"( %.0f %.0f %.0f ) ( %.0f %.0f %.0f ) ( %.0f %.0f %.0f ) "
"%s "
"[ %g %g %g %g ] "
"[ %g %g %g %g ] "
"%g %g %g ",
plane.planepts[0][0], plane.planepts[0][1], plane.planepts[0][2],
plane.planepts[1][0], plane.planepts[1][1], plane.planepts[1][2],
plane.planepts[2][0], plane.planepts[2][1], plane.planepts[2][2],
pszTexture,
(double)texture.UAxis[0], (double)texture.UAxis[1], (double)texture.UAxis[2], (double)texture.UAxis[3],
(double)texture.VAxis[0], (double)texture.VAxis[1], (double)texture.VAxis[2], (double)texture.VAxis[3],
(double)texture.rotate,
(double)texture.scale[0],
(double)texture.scale[1]);
file << szBuf << ENDLINE;
return fileOk;
}
else
{
// load the plane
GetLine(file, szBuf);
if(szBuf[0] != '(')
{
StuffLine(szBuf);
return fileDone;
}
char szTexName[TEXTURE_NAME_LEN];
DWORD q2contents;
DWORD q2surface;
int nLightmapScale;
int nDummy;
int nRead;
if( uMapVersion >= 340 )
{
COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
nRead = sscanf(szBuf,
"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
"%127s "
"[ %f %f %f %f ] "
"[ %f %f %f %f ] "
"%f %f %f "
"%u %u %u",
&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
szTexName,
&texture.UAxis[0], &texture.UAxis[1], &texture.UAxis[2], &texture.UAxis[3],
&texture.VAxis[0], &texture.VAxis[1], &texture.VAxis[2], &texture.VAxis[3],
&texture.rotate,
&texture.scale[0],
&texture.scale[1],
&q2contents,
&q2surface,
&nLightmapScale);
// Guarantee null-termination to keep /analyze happy.
szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;
if (nRead < 21)
{
bErrors = TRUE;
}
else if (nRead == 24)
{
// got q2 values - set them here
texture.q2contents = q2contents;
texture.q2surface = q2surface;
texture.nLightmapScale = nLightmapScale;
if (texture.nLightmapScale == 0)
{
texture.nLightmapScale = g_pGameConfig->GetDefaultLightmapScale();
}
}
//
// very cheesy HACK!!! -- this will be better when we have chunks
//
if( uMapVersion <= 350 )
{
if( ( file.peek() != '(' ) && ( file.peek() != '}' ) )
{
EditDispHandle_t handle = EditDispMgr()->Create();
SetDisp( handle );
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
pDisp->SerializedLoadMAP( file, this, uMapVersion );
}
}
}
else if (uMapVersion >= 220 )
{
COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
nRead = sscanf(szBuf,
"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
"%127s "
"[ %f %f %f %f ] "
"[ %f %f %f %f ] "
"%f %f %f "
"%u %u %u",
&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
szTexName,
&texture.UAxis[0], &texture.UAxis[1], &texture.UAxis[2], &texture.UAxis[3],
&texture.VAxis[0], &texture.VAxis[1], &texture.VAxis[2], &texture.VAxis[3],
&texture.rotate,
&texture.scale[0],
&texture.scale[1],
&q2contents,
&q2surface,
&nDummy); // Pre-340 didn't have lightmap scale.
// Guarantee null-termination to keep /analyze happy.
szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;
if (nRead < 21)
{
bErrors = TRUE;
}
else if (nRead == 24)
{
// got q2 values - set them here
texture.q2contents = q2contents;
texture.q2surface = q2surface;
}
}
else
{
COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
nRead = sscanf(szBuf,
"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
"%127s "
"%f %f %f "
"%f %f %u %u %u",
&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
szTexName,
&texture.UAxis[3],
&texture.VAxis[3],
&texture.rotate,
&texture.scale[0],
&texture.scale[1],
&q2contents,
&q2surface,
&nDummy); // Pre-340 didn't have lightmap scale.
// Guarantee null-termination to keep /analyze happy.
szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;
if (nRead < 15)
{
bErrors = TRUE;
}
else if (nRead == 18)
{
// got q2 values - set them here
texture.q2contents = q2contents;
texture.q2surface = q2surface;
}
}
if (g_pGameConfig->GetTextureFormat() != tfVMT)
{
// reverse the slashes -- thank you id
for (int i = strlen(szTexName) - 1; i >= 0; i--)
{
if (szTexName[i] == '/')
szTexName[i] = '\\';
}
}
SetTexture(szTexName);
}
if (file.fail())
{
return fileOsError;
}
return fileOk;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int MDkeyvalue::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
// load/save a keyvalue
char szBuf[1024];
if(fIsStoring)
{
// save a keyvalue
sprintf( szBuf,
"\"%s\" \"%s\"",
Key(), Value() );
file << szBuf << ENDLINE;
}
else
{
GetLine(file, szBuf);
if(szBuf[0] != '\"')
{
StuffLine(szBuf);
return fileDone;
}
char *p = strchr(szBuf, '\"');
p = strchr(p+1, '\"');
if(!p)
return fileError;
p[0] = 0;
V_strcpy_safe(szKey, szBuf+1);
// advance to start of value string
p = strchr(p+1, '\"');
if(!p)
return fileError;
// ocpy in value
strcpy(szValue, p+1);
// kill trailing "
p = strchr(szValue, '\"');
if(!p)
return fileError;
p[0] = 0;
}
return file.fail() ? fileOsError : fileOk;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int CMapSolid::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
CMapClass::SerializeMAP(file, fIsStoring);
// load/save a brush
if (fIsStoring)
{
// save the brush
file << "{" << ENDLINE;
// serialize the Faces
int nFaces = Faces.GetCount();
for(int i = 0; i < nFaces; i++)
{
if(!Faces[i].Points)
continue;
if(Faces[i].SerializeMAP(file, fIsStoring) == fileError)
return fileError;
}
// terminator
file << "}" << ENDLINE;
}
else
{
// caller skipped delimiter
Faces.SetCount(0);
// read Faces
for(int i = 0; ; i++)
{
// extract plane
if (Faces[i].SerializeMAP(file, fIsStoring) == fileDone)
{
// when fileDone is returned, no face was loaded
break;
}
Faces[i].CalcPlane();
}
GetLine(file, NULL); // ignore line
if (!file.fail())
{
//
// Create the solid using the planes that were read from the MAP file.
//
if (CreateFromPlanes() == FALSE)
{
bErrors = TRUE;
return(fileError);
}
//
// If we are reading from an old map file, the texture axes will need to be set up.
// Leave the rotation and shifts alone; they were read from the MAP file.
//
if (uMapVersion < 220)
{
InitializeTextureAxes(TEXTURE_ALIGN_QUAKE, INIT_TEXTURE_AXES | INIT_TEXTURE_FORCE);
}
}
else
{
return(fileOsError);
}
CalcBounds();
//
// Set solid type based on texture name.
//
m_eSolidType = HL1SolidTypeFromTextureName(Faces[0].texture.texture);
}
return(file.fail() ? fileOsError : fileOk);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int CMapEntity::SerializeMAP(std::fstream &file, BOOL fIsStoring)
{
CMapClass::SerializeMAP(file, fIsStoring);
// load/save an object
if (fIsStoring)
{
//
// If it's a solidentity but it doesn't have any solids,
// don't save it.
//
if (!IsPlaceholder() && !m_Children.Count())
{
return(fileOk);
}
//
// Save it.
//
file << "{" << ENDLINE;
//
// Save keyvalues & other data.
//
CEditGameClass::SerializeMAP(file, fIsStoring);
//
// If this is a placeholder and either has no class or is not a solid class,
// save our origin.
//
if (IsPlaceholder() && (!IsClass() || !IsSolidClass()))
{
MDkeyvalue tmpkv;
strcpy(tmpkv.szKey, "origin");
Vector Origin;
GetOrigin(Origin);
sprintf(tmpkv.szValue, "%.0f %.0f %.0f", Origin[0], Origin[1], Origin[2]);
tmpkv.SerializeMAP(file, fIsStoring);
}
if (!(IsPlaceholder()))
{
SaveSolidChildrenOf(this, file);
}
file << "}" << ENDLINE;
}
else
{
// load keyvalues
CEditGameClass::SerializeMAP(file, fIsStoring);
// solids
if (!ReadSolids(this, file))
{
flags |= flagPlaceholder;
}
// skip delimiter
GetLine(file, NULL);
}
return file.fail() ? fileOsError : fileOk;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// Output : int
//-----------------------------------------------------------------------------
int CEditGameClass::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
int iRvl;
if (!fIsStoring)
{
// loading
if (PeekChar(file) == '\"')
{
// read kv pairs
MDkeyvalue newkv;
while (1)
{
if (newkv.SerializeMAP(file, fIsStoring) != fileOk)
{
// fileDone means the keyvalue was not loaded
break;
}
if (!strcmp(newkv.szKey, "classname"))
{
m_KeyValues.SetValue(newkv.szKey, newkv.szValue);
}
else if (!strcmp(newkv.szKey, "angle"))
{
ImportAngle(atoi(newkv.szValue));
}
else if (strcmp(newkv.szKey, "wad"))
{
//
// All other keys are simply added to the keyvalue list.
//
m_KeyValues.SetValue(newkv.szKey, newkv.szValue);
}
}
}
}
else
{
// save keyvalues
MDkeyvalue tmpkv;
if (GetKeyValue("classname") == NULL)
{
tmpkv.Set("classname", m_szClass);
tmpkv.SerializeMAP(file, fIsStoring);
}
//
// Determine whether we have a game data class. This will help us decide which keys
// to write.
//
GDclass *pGameDataClass = NULL;
if (pGD != NULL)
{
pGameDataClass = pGD->ClassForName(m_szClass);
}
//
// Consider all the keyvalues in this object for serialization.
//
for ( int z=m_KeyValues.GetFirst(); z != m_KeyValues.GetInvalidIndex(); z=m_KeyValues.GetNext( z ) )
{
MDkeyvalue &KeyValue = m_KeyValues.GetKeyValue(z);
iRvl = KeyValue.SerializeMAP(file, fIsStoring);
if (iRvl != fileOk)
{
return(iRvl);
}
}
//
// If we have a base class, for each keyvalue in the class definition, write out all keys
// that are not present in the object and whose defaults are nonzero in the class definition.
//
if (pGameDataClass != NULL)
{
//
// For each variable from the base class...
//
int nVariableCount = pGameDataClass->GetVariableCount();
for (int i = 0; i < nVariableCount; i++)
{
GDinputvariable *pVar = pGameDataClass->GetVariableAt(i);
Assert(pVar != NULL);
if (pVar != NULL)
{
int iIndex;
MDkeyvalue *pKey;
LPCTSTR p = m_KeyValues.GetValue(pVar->GetName(), &iIndex);
//
// If the variable is not present in this object, write out the default value.
//
if (p == NULL)
{
pKey = &tmpkv;
pVar->ResetDefaults();
pVar->ToKeyValue(pKey);
//
// Only write the key value if it is non-zero.
//
if ((pKey->szKey[0] != 0) && (pKey->szValue[0] != 0) && (stricmp(pKey->szValue, "0")))
{
iRvl = pKey->SerializeMAP(file, fIsStoring);
if (iRvl != fileOk)
{
return(iRvl);
}
}
}
}
}
}
}
return(file.fail() ? fileOsError : fileOk);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
// fIsStoring -
// pIntersecting -
// Output : int
//-----------------------------------------------------------------------------
int CMapWorld::SerializeMAP(std::fstream &file, BOOL fIsStoring, BoundBox *pIntersecting)
{
int iRvl;
bStuffed = FALSE;
bErrors = FALSE;
nInvalidSolids = 0;
// load/save a world
if (fIsStoring)
{
file << "{" << ENDLINE;
// save worldobject
CEditGameClass::SerializeMAP(file, fIsStoring);
if (MapFormat != mfQuake2)
{
MDkeyvalue tmpkv;
strcpy(tmpkv.szKey, "mapversion");
strcpy(tmpkv.szValue, "360");
tmpkv.SerializeMAP(file, fIsStoring);
// Save wad file line
strcpy(tmpkv.szKey, "wad");
// copy all texfiles into value
tmpkv.szValue[0] = 0;
BOOL bFirst = TRUE;
int nGraphicsFiles = g_Textures.FilesGetCount();
for (int i = 0; i < nGraphicsFiles; i++)
{
char szFile[MAX_PATH];
GRAPHICSFILESTRUCT gf;
g_Textures.FilesGetInfo(&gf, i);
//
// Don't save WAL files - they're never used.
//
if (gf.format != tfWAL)
{
//
// Also make sure this is the right kind of WAD file
// based on the game we're using.
//
if (gf.format == g_pGameConfig->GetTextureFormat())
{
//
// Append this WAD file to the WAD list.
//
strcpy(szFile, gf.filename);
// dvs: Strip off the path. This crashes VIS and QRAD!!
/*
char *pszSlash = strrchr(szFile, '\\');
if (pszSlash == NULL)
{
pszSlash = strrchr(szFile, '/');
}
if (pszSlash != NULL)
{
pszSlash++;
}
else
{
pszSlash = szFile;
}
*/
char *pszSlash = szFile;
// Strip off any drive letter.
if (pszSlash[1] == ':')
{
pszSlash += 2;
}
// WAD names are semicolon delimited.
if (!bFirst)
{
strcat(tmpkv.szValue, ";");
}
strcat(tmpkv.szValue, pszSlash);
bFirst = FALSE;
}
}
}
if ( tmpkv.szValue[0] != '\0' )
{
tmpkv.SerializeMAP(file, fIsStoring);
}
}
//
// Save the brushes.
//
if (SaveSolidChildrenOf(this, file, pIntersecting) == fileOsError)
{
goto FatalError;
}
file << "}" << ENDLINE;
//
// Save the entities.
//
if (SaveEntityChildrenOf(this, file, pIntersecting) == fileOsError)
{
goto FatalError;
}
//
// Save paths (if paths are visible).
//
FOR_EACH_OBJ( m_Paths, pos )
{
CMapPath *pPath = m_Paths.Element(pos);
pPath->SerializeMAP(file, TRUE, pIntersecting);
}
}
else
{
pProgDlg = new CProgressDlg;
pProgDlg->Create();
pProgDlg->SetStep(1);
CString caption;
caption.LoadString(IDS_LOADINGFILE);
pProgDlg->SetWindowText(caption);
m_Render2DBox.ResetBounds();
// load world
GetLine(file, NULL); // ignore delimiter
CEditGameClass::SerializeMAP(file, fIsStoring);
const char* pszMapVersion;
pszMapVersion = m_KeyValues.GetValue("mapversion");
if (pszMapVersion != NULL)
{
uMapVersion = atoi(pszMapVersion);
}
else
{
uMapVersion = 0;
}
// read solids
if (ReadSolids(this, file) == fileOsError)
{
goto FatalError;
}
// skip end-of-entity marker
GetLine(file, NULL);
char szBuf[128];
// read entities
while (1)
{
GetLine(file, szBuf);
if (szBuf[0] != '{')
{
StuffLine(szBuf);
break;
}
if (PeekChar(file) == EOF)
{
break;
}
CMapEntity *pEntity;
pEntity = new CMapEntity;
iRvl = pEntity->SerializeMAP(file, fIsStoring);
AddChild(pEntity);
if (iRvl == fileError)
{
bErrors = TRUE;
}
else if (iRvl == fileOsError)
{
goto FatalError;
}
}
if (bErrors)
{
if (nInvalidSolids)
{
CString str;
str.Format("For your information, %d solids were not loaded\n"
"due to errors in the file.", nInvalidSolids);
AfxMessageBox(str);
}
else if (AfxMessageBox("There was a problem loading the MAP file. Do you\n"
"want to view the error report?", MB_YESNO) == IDYES)
{
CMapErrorsDlg dlg;
dlg.DoModal();
}
}
PostloadWorld();
if (g_pGameConfig->GetTextureFormat() == tfVMT)
{
// do batch search and replace of textures from trans.txt if it exists.
char translationFilename[MAX_PATH];
Q_snprintf( translationFilename, sizeof( translationFilename ), "materials/trans.txt" );
if( CMapDoc::GetActiveMapDoc() )
{
FileHandle_t searchReplaceFP = g_pFileSystem->Open( translationFilename, "r" );
if( searchReplaceFP )
{
CMapDoc::GetActiveMapDoc()->BatchReplaceTextures( searchReplaceFP );
g_pFileSystem->Close( searchReplaceFP );
}
}
}
}
if (pProgDlg)
{
pProgDlg->DestroyWindow();
delete pProgDlg;
pProgDlg = NULL;
}
return (bErrors && fIsStoring) ? -1 : 0;
FatalError:
// OS error.
CString str;
str.Format("The OS reported an error %s the file: %s", fIsStoring ? "saving" : "loading", strerror(errno));
AfxMessageBox(str);
if (pProgDlg != NULL)
{
pProgDlg->DestroyWindow();
delete pProgDlg;
pProgDlg = NULL;
}
return -1;
}