992 lines
24 KiB
C++
992 lines
24 KiB
C++
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
// Purpose: Implements a system for managing prefabs. There are two types
|
||
|
|
// of prefabs implemented here: Half-Life style prefabs, and Half-Life 2
|
||
|
|
// style prefabs.
|
||
|
|
//
|
||
|
|
// For Half-Life, prefab libraries are stored as binary .OL files, each of
|
||
|
|
// which contains multiple .RMF files that are the prefabs.
|
||
|
|
//
|
||
|
|
// For Half-Life 2, prefabs are stored in a tree of folders, each folder
|
||
|
|
// representing a library, and the each .VMF file in the folder containing
|
||
|
|
// a single prefab.
|
||
|
|
//
|
||
|
|
//=============================================================================//
|
||
|
|
|
||
|
|
|
||
|
|
#include "stdafx.h"
|
||
|
|
#include "Prefabs.h"
|
||
|
|
#include "Prefab3D.h"
|
||
|
|
#include "hammer.h"
|
||
|
|
#include <io.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include <tier0/memdbgon.h>
|
||
|
|
|
||
|
|
|
||
|
|
BOOL CPrefab::bCacheEnabled = TRUE;
|
||
|
|
CPrefabList CPrefab::PrefabList;
|
||
|
|
CPrefabList CPrefab::MRU;
|
||
|
|
CPrefabLibraryList CPrefabLibrary::PrefabLibraryList;
|
||
|
|
|
||
|
|
|
||
|
|
static char *pLibHeader = "Worldcraft Prefab Library\r\n\x1a";
|
||
|
|
static float fLibVersion = 0.1f;
|
||
|
|
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
DWORD dwOffset;
|
||
|
|
DWORD dwSize;
|
||
|
|
char szName[31];
|
||
|
|
char szNotes[MAX_NOTES];
|
||
|
|
int iType;
|
||
|
|
} PrefabHeader;
|
||
|
|
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
float fVersion;
|
||
|
|
DWORD dwDirOffset;
|
||
|
|
DWORD dwNumEntries;
|
||
|
|
char szNotes[MAX_NOTES];
|
||
|
|
} PrefabLibraryHeader;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Creates a prefab library from a given path.
|
||
|
|
// Input : szFile -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary *CreatePrefabLibrary(const char *szFile)
|
||
|
|
{
|
||
|
|
CPrefabLibrary *pLibrary;
|
||
|
|
|
||
|
|
if (stricmp(&szFile[strlen(szFile) - 2], ".ol") != 0)
|
||
|
|
{
|
||
|
|
pLibrary = new CPrefabLibraryVMF;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pLibrary = new CPrefabLibraryRMF;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pLibrary->Load(szFile) == -1)
|
||
|
|
{
|
||
|
|
delete pLibrary;
|
||
|
|
return(NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
return(pLibrary);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefab::CPrefab()
|
||
|
|
{
|
||
|
|
static DWORD dwRunningID = 1;
|
||
|
|
// assign running ID
|
||
|
|
dwID = dwRunningID++;
|
||
|
|
PrefabList.AddTail(this);
|
||
|
|
|
||
|
|
// assign blank name/notes
|
||
|
|
szName[0] = szNotes[0] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefab::~CPrefab()
|
||
|
|
{
|
||
|
|
POSITION p = PrefabList.Find(this);
|
||
|
|
if(p)
|
||
|
|
PrefabList.RemoveAt(p);
|
||
|
|
p = MRU.Find(this);
|
||
|
|
if(p)
|
||
|
|
MRU.RemoveAt(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : dwID -
|
||
|
|
// Output : CPrefab *
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefab * CPrefab::FindID(DWORD dwID)
|
||
|
|
{
|
||
|
|
POSITION p = PrefabList.GetHeadPosition();
|
||
|
|
while(p)
|
||
|
|
{
|
||
|
|
CPrefab *pPrefab = PrefabList.GetNext(p);
|
||
|
|
if(pPrefab->dwID == dwID)
|
||
|
|
return pPrefab;
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : b -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefab::EnableCaching(BOOL b)
|
||
|
|
{
|
||
|
|
bCacheEnabled = b;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : *pPrefab -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefab::AddMRU(CPrefab *pPrefab)
|
||
|
|
{
|
||
|
|
if(!bCacheEnabled)
|
||
|
|
return;
|
||
|
|
|
||
|
|
POSITION p = MRU.Find(pPrefab);
|
||
|
|
if(p)
|
||
|
|
{
|
||
|
|
// remove there and add to head
|
||
|
|
MRU.RemoveAt(p);
|
||
|
|
}
|
||
|
|
else if(MRU.GetCount() == 5)
|
||
|
|
{
|
||
|
|
// uncache tail object
|
||
|
|
p = MRU.GetTailPosition();
|
||
|
|
if(p) // might not be any yet
|
||
|
|
{
|
||
|
|
CPrefab *pUncache = MRU.GetAt(p);
|
||
|
|
pUncache->FreeData();
|
||
|
|
MRU.RemoveAt(p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// add to head
|
||
|
|
MRU.AddHead(pPrefab);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefab::FreeAllData()
|
||
|
|
{
|
||
|
|
// free all prefab data memory
|
||
|
|
POSITION p = PrefabList.GetHeadPosition();
|
||
|
|
while(p)
|
||
|
|
{
|
||
|
|
CPrefab *pPrefab = PrefabList.GetNext(p);
|
||
|
|
pPrefab->FreeData();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// Output : CPrefab::pfiletype_t
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefab::pfiletype_t CPrefab::CheckFileType(LPCTSTR pszFilename)
|
||
|
|
{
|
||
|
|
// first check extensions
|
||
|
|
const char *p = strrchr(pszFilename, '.');
|
||
|
|
if(p)
|
||
|
|
{
|
||
|
|
if(!strcmpi(p, ".rmf"))
|
||
|
|
return pftRMF;
|
||
|
|
else if(!strcmpi(p, ".map"))
|
||
|
|
return pftMAP;
|
||
|
|
else if(!strcmpi(p, ".os"))
|
||
|
|
return pftScript;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::fstream file(pszFilename, std::ios::in | std::ios::binary);
|
||
|
|
|
||
|
|
// read first 16 bytes of file
|
||
|
|
char szBuf[255];
|
||
|
|
file.read(szBuf, 16);
|
||
|
|
|
||
|
|
// check 1: RMF
|
||
|
|
float f = ((float*) szBuf)[0];
|
||
|
|
|
||
|
|
// 0.8 was version at which RMF tag was started
|
||
|
|
if(f <= 0.7f || !strncmp(szBuf+sizeof(float), "RMF", 3))
|
||
|
|
{
|
||
|
|
return pftRMF;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check 2: script
|
||
|
|
if(!strnicmp(szBuf, "[Script", 7))
|
||
|
|
{
|
||
|
|
return pftScript;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check 3: MAP
|
||
|
|
int i = 500;
|
||
|
|
while(i--)
|
||
|
|
{
|
||
|
|
file >> std::ws;
|
||
|
|
file.getline(szBuf, 255);
|
||
|
|
if(szBuf[0] == '{')
|
||
|
|
return pftMAP;
|
||
|
|
if(file.eof())
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pftUnknown;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary::CPrefabLibrary()
|
||
|
|
{
|
||
|
|
static DWORD dwRunningID = 1;
|
||
|
|
// assign running ID
|
||
|
|
dwID = dwRunningID++;
|
||
|
|
m_szName[0] = '\0';
|
||
|
|
szNotes[0] = '\0';
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary::~CPrefabLibrary()
|
||
|
|
{
|
||
|
|
FreePrefabs();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::FreePrefabs()
|
||
|
|
{
|
||
|
|
// nuke prefabs
|
||
|
|
POSITION p = Prefabs.GetHeadPosition();
|
||
|
|
while (p != NULL)
|
||
|
|
{
|
||
|
|
CPrefab *pPrefab = Prefabs.GetNext(p);
|
||
|
|
delete pPrefab;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : *a -
|
||
|
|
// *b -
|
||
|
|
// Output : static int
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static int __cdecl SortPrefabs(CPrefab *a, CPrefab *b)
|
||
|
|
{
|
||
|
|
return(strcmpi(a->GetName(), b->GetName()));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::Sort(void)
|
||
|
|
{
|
||
|
|
int nPrefabs = Prefabs.GetCount();
|
||
|
|
if (nPrefabs < 2)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
CPrefab **TmpPrefabArray = new CPrefab *[nPrefabs];
|
||
|
|
|
||
|
|
//
|
||
|
|
// Make an array we can pass to qsort.
|
||
|
|
//
|
||
|
|
POSITION p = ENUM_START;
|
||
|
|
CPrefab *pPrefab = EnumPrefabs(p);
|
||
|
|
int iPrefab = 0;
|
||
|
|
while (pPrefab != NULL)
|
||
|
|
{
|
||
|
|
TmpPrefabArray[iPrefab++] = pPrefab;
|
||
|
|
pPrefab = EnumPrefabs(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Sort the prefabs array by name.
|
||
|
|
//
|
||
|
|
qsort(TmpPrefabArray, nPrefabs, sizeof(CPrefab *), (int (__cdecl *)(const void *, const void *))SortPrefabs);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Store back in list in sorted order.
|
||
|
|
//
|
||
|
|
Prefabs.RemoveAll();
|
||
|
|
for (int i = 0; i < nPrefabs; i++)
|
||
|
|
{
|
||
|
|
Prefabs.AddTail(TmpPrefabArray[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
delete[] TmpPrefabArray;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::SetNameFromFilename(LPCTSTR pszFilename)
|
||
|
|
{
|
||
|
|
const char *cp = strrchr(pszFilename, '\\');
|
||
|
|
strcpy(m_szName, cp ? (cp + 1) : pszFilename);
|
||
|
|
char *p = strchr(m_szName, '.');
|
||
|
|
if (p != NULL)
|
||
|
|
{
|
||
|
|
p[0] = '\0';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Frees all the libraries in the prefab library list.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::FreeAllLibraries(void)
|
||
|
|
{
|
||
|
|
POSITION pos = PrefabLibraryList.GetHeadPosition();
|
||
|
|
while (pos != NULL)
|
||
|
|
{
|
||
|
|
CPrefabLibrary *pPrefabLibrary = PrefabLibraryList.GetNext(pos);
|
||
|
|
if (pPrefabLibrary != NULL)
|
||
|
|
{
|
||
|
|
delete pPrefabLibrary;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
PrefabLibraryList.RemoveAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Load all libraries in the prefabs directory.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::LoadAllLibraries()
|
||
|
|
{
|
||
|
|
char szDir[MAX_PATH];
|
||
|
|
char szFile[MAX_PATH];
|
||
|
|
((CHammer *)AfxGetApp())->GetDirectory(DIR_PREFABS, szDir);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Add one prefab library for the root prefabs folder in case they put something there.
|
||
|
|
//
|
||
|
|
CPrefabLibrary *pLibrary = FindOpenLibrary(szDir);
|
||
|
|
if (pLibrary == NULL)
|
||
|
|
{
|
||
|
|
pLibrary = CreatePrefabLibrary(szDir);
|
||
|
|
if (pLibrary != NULL)
|
||
|
|
{
|
||
|
|
PrefabLibraryList.AddTail(pLibrary);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pLibrary->Load(szDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
strcat(szDir, "\\*.*");
|
||
|
|
|
||
|
|
WIN32_FIND_DATA fd;
|
||
|
|
HANDLE hnd = FindFirstFile(szDir, &fd);
|
||
|
|
strrchr(szDir, '\\')[0] = 0; // truncate that
|
||
|
|
|
||
|
|
if (hnd == INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
return; // no libraries
|
||
|
|
}
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && (fd.cFileName[0] != '.'))
|
||
|
|
{
|
||
|
|
sprintf(szFile, "%s\\%s", szDir, fd.cFileName);
|
||
|
|
|
||
|
|
pLibrary = FindOpenLibrary(szFile);
|
||
|
|
if (pLibrary == NULL)
|
||
|
|
{
|
||
|
|
pLibrary = CreatePrefabLibrary(szFile);
|
||
|
|
if (pLibrary != NULL)
|
||
|
|
{
|
||
|
|
PrefabLibraryList.AddTail(pLibrary);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pLibrary->Load(szDir);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} while (FindNextFile(hnd, &fd));
|
||
|
|
|
||
|
|
FindClose(hnd);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : *pPrefab -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::Add(CPrefab *pPrefab)
|
||
|
|
{
|
||
|
|
if(!Prefabs.Find(pPrefab))
|
||
|
|
Prefabs.AddTail(pPrefab);
|
||
|
|
pPrefab->dwLibID = dwID;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : *pPrefab -
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CPrefabLibrary::Remove(CPrefab *pPrefab)
|
||
|
|
{
|
||
|
|
POSITION p = Prefabs.Find(pPrefab);
|
||
|
|
if(p)
|
||
|
|
Prefabs.RemoveAt(p);
|
||
|
|
if(pPrefab->dwLibID == dwID) // make sure it doesn't reference this
|
||
|
|
pPrefab->dwLibID = 0xffff;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : &p -
|
||
|
|
// Output : CPrefab *
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefab * CPrefabLibrary::EnumPrefabs(POSITION &p)
|
||
|
|
{
|
||
|
|
if(p == ENUM_START)
|
||
|
|
p = Prefabs.GetHeadPosition();
|
||
|
|
if(!p)
|
||
|
|
return NULL;
|
||
|
|
return Prefabs.GetNext(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : dwID -
|
||
|
|
// Output : CPrefabLibrary *
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary * CPrefabLibrary::FindID(DWORD dwID)
|
||
|
|
{
|
||
|
|
POSITION p = PrefabLibraryList.GetHeadPosition();
|
||
|
|
while(p)
|
||
|
|
{
|
||
|
|
CPrefabLibrary *pPrefabLibrary = PrefabLibraryList.GetNext(p);
|
||
|
|
if(pPrefabLibrary->dwID == dwID)
|
||
|
|
return pPrefabLibrary;
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary *CPrefabLibrary::FindOpenLibrary(LPCTSTR pszFilename)
|
||
|
|
{
|
||
|
|
// checks to see if a library is open under that filename
|
||
|
|
POSITION p = ENUM_START;
|
||
|
|
CPrefabLibrary *pLibrary = EnumLibraries(p);
|
||
|
|
while (pLibrary != NULL)
|
||
|
|
{
|
||
|
|
if (pLibrary->IsFile(pszFilename))
|
||
|
|
{
|
||
|
|
return(pLibrary);
|
||
|
|
}
|
||
|
|
pLibrary = EnumLibraries(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
return(NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Enumerates the prefab libraries of a given type.
|
||
|
|
// Input : p - Iterator.
|
||
|
|
// eType - Type of library to return, LibType_None returns all
|
||
|
|
// library types.
|
||
|
|
// Output : Returns the next library of the given type.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibrary *CPrefabLibrary::EnumLibraries(POSITION &p, LibraryType_t eType)
|
||
|
|
{
|
||
|
|
if (p == ENUM_START)
|
||
|
|
{
|
||
|
|
p = PrefabLibraryList.GetHeadPosition();
|
||
|
|
}
|
||
|
|
|
||
|
|
while (p != NULL)
|
||
|
|
{
|
||
|
|
CPrefabLibrary *pLibrary = PrefabLibraryList.GetNext(p);
|
||
|
|
if ((eType == LibType_None) || pLibrary->IsType(eType))
|
||
|
|
{
|
||
|
|
return(pLibrary);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return(NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibraryRMF::CPrefabLibraryRMF()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibraryRMF::~CPrefabLibraryRMF()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Returns true if this prefab represents the given filename, false if not.
|
||
|
|
// Input : szFilename - Path of a prefab library or folder.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CPrefabLibraryRMF::IsFile(const char *szFilename)
|
||
|
|
{
|
||
|
|
return(strcmpi(m_strOpenFileName, szFilename) == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// Output : int
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryRMF::Load(LPCTSTR pszFilename)
|
||
|
|
{
|
||
|
|
FreePrefabs();
|
||
|
|
|
||
|
|
m_eType = LibType_HalfLife;
|
||
|
|
|
||
|
|
// open file
|
||
|
|
m_file.open(pszFilename, std::ios::in | std::ios::binary);
|
||
|
|
m_strOpenFileName = pszFilename;
|
||
|
|
|
||
|
|
if(!m_file.is_open())
|
||
|
|
return -1;
|
||
|
|
|
||
|
|
char szBuf[128];
|
||
|
|
|
||
|
|
// read string header
|
||
|
|
m_file.read(szBuf, strlen(pLibHeader));
|
||
|
|
if(strncmp(szBuf, pLibHeader, strlen(pLibHeader)))
|
||
|
|
{
|
||
|
|
// return
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// read binary header
|
||
|
|
PrefabLibraryHeader plh;
|
||
|
|
m_file.read((char*)&plh, sizeof(plh));
|
||
|
|
strcpy(szNotes, plh.szNotes);
|
||
|
|
|
||
|
|
// set name from filename
|
||
|
|
SetNameFromFilename(pszFilename);
|
||
|
|
|
||
|
|
// read directory
|
||
|
|
PrefabHeader *ph = new PrefabHeader[plh.dwNumEntries];
|
||
|
|
m_dwDirOffset = plh.dwDirOffset;
|
||
|
|
m_file.seekg(plh.dwDirOffset);
|
||
|
|
m_file.read((char*)ph, plh.dwNumEntries * sizeof(PrefabHeader));
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read each prefab.
|
||
|
|
//
|
||
|
|
for(DWORD i = 0; i < plh.dwNumEntries; i++)
|
||
|
|
{
|
||
|
|
Assert(ph[i].iType == pt3D);
|
||
|
|
CPrefabRMF *pPrefab = new CPrefabRMF;
|
||
|
|
|
||
|
|
// seek to prefab
|
||
|
|
m_file.seekg(ph[i].dwOffset);
|
||
|
|
pPrefab->Init(m_file);
|
||
|
|
|
||
|
|
// set its other info frm the dir entry
|
||
|
|
pPrefab->SetName(ph[i].szName);
|
||
|
|
pPrefab->SetNotes(ph[i].szNotes);
|
||
|
|
pPrefab->dwFileSize = ph[i].dwSize;
|
||
|
|
pPrefab->dwFileOffset = ph[i].dwOffset;
|
||
|
|
|
||
|
|
Add(pPrefab);
|
||
|
|
}
|
||
|
|
|
||
|
|
// delete directory
|
||
|
|
delete[] ph;
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Removes this prefab library from disk.
|
||
|
|
// Output : Returns true on success, false on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CPrefabLibraryRMF::DeleteFile(void)
|
||
|
|
{
|
||
|
|
return(remove(m_strOpenFileName) == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// bIndexOnly -
|
||
|
|
// Output : int
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryRMF::Save(LPCTSTR pszFilename, BOOL bIndexOnly)
|
||
|
|
{
|
||
|
|
// temp storage
|
||
|
|
static char szFile[MAX_PATH];
|
||
|
|
|
||
|
|
// if only saving index, special code -
|
||
|
|
if(bIndexOnly && m_file.is_open())
|
||
|
|
{
|
||
|
|
// close file, reopen in binary write
|
||
|
|
m_file.close();
|
||
|
|
if(Prefabs.GetCount())
|
||
|
|
{
|
||
|
|
// change size of file first
|
||
|
|
int iHandle = _open(m_strOpenFileName, _O_BINARY | _O_WRONLY);
|
||
|
|
_chsize(iHandle, m_dwDirOffset);
|
||
|
|
_close(iHandle);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::fstream file(m_strOpenFileName, std::ios::binary | std::ios::out);
|
||
|
|
|
||
|
|
// write string header
|
||
|
|
file << pLibHeader;
|
||
|
|
// write binary header (in case notes have changed)
|
||
|
|
PrefabLibraryHeader plh;
|
||
|
|
plh.dwNumEntries = Prefabs.GetCount();
|
||
|
|
plh.fVersion = fLibVersion;
|
||
|
|
plh.dwDirOffset = m_dwDirOffset;
|
||
|
|
strcpy(plh.szNotes, szNotes);
|
||
|
|
file.write((char*)&plh, sizeof plh);
|
||
|
|
|
||
|
|
// recreate a directory and write it
|
||
|
|
PrefabHeader *ph = new PrefabHeader[Prefabs.GetCount()];
|
||
|
|
int iCur = 0;
|
||
|
|
|
||
|
|
POSITION p = Prefabs.GetHeadPosition();
|
||
|
|
while(p)
|
||
|
|
{
|
||
|
|
CPrefab *pPrefab = Prefabs.GetNext(p);
|
||
|
|
|
||
|
|
// setup this dir entry
|
||
|
|
ph[iCur].dwOffset = pPrefab->dwFileOffset;
|
||
|
|
ph[iCur].dwSize = pPrefab->dwFileSize;
|
||
|
|
V_strcpy_safe(ph[iCur].szName, pPrefab->GetName());
|
||
|
|
V_strcpy_safe(ph[iCur].szNotes, pPrefab->GetNotes());
|
||
|
|
ph[iCur].iType = pPrefab->GetType();
|
||
|
|
|
||
|
|
++iCur; // increase current directory entry
|
||
|
|
}
|
||
|
|
|
||
|
|
// write directory
|
||
|
|
file.seekp(m_dwDirOffset);
|
||
|
|
file.write((char*)ph, sizeof(*ph) * Prefabs.GetCount());
|
||
|
|
file.close();
|
||
|
|
|
||
|
|
// re-open
|
||
|
|
m_file.open(m_strOpenFileName, std::ios::in | std::ios::binary);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pszFilename == NULL)
|
||
|
|
{
|
||
|
|
pszFilename = szFile;
|
||
|
|
|
||
|
|
if(m_strOpenFileName.IsEmpty())
|
||
|
|
{
|
||
|
|
char szNewFilename[MAX_PATH];
|
||
|
|
CHammer *pApp = (CHammer*) AfxGetApp();
|
||
|
|
pApp->GetDirectory(DIR_PREFABS, szNewFilename);
|
||
|
|
|
||
|
|
sprintf(szNewFilename + strlen(szNewFilename), "\\%s.ol", m_szName);
|
||
|
|
|
||
|
|
// make a name
|
||
|
|
m_strOpenFileName = szNewFilename;
|
||
|
|
}
|
||
|
|
|
||
|
|
strcpy(szFile, m_strOpenFileName);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
strcpy(szFile, pszFilename);
|
||
|
|
SetNameFromFilename(pszFilename);
|
||
|
|
}
|
||
|
|
|
||
|
|
// open temp file to save to.. then delete & rename old one.
|
||
|
|
CString strTempFileName = "Temporary Prefab Library.$$$";
|
||
|
|
std::fstream file;
|
||
|
|
file.open(strTempFileName, std::ios::binary | std::ios::out);
|
||
|
|
|
||
|
|
// write string header
|
||
|
|
file << pLibHeader;
|
||
|
|
|
||
|
|
// write binary header
|
||
|
|
// save current position so we can seek back and rewrite it
|
||
|
|
DWORD dwBinaryHeaderOffset = file.tellp();
|
||
|
|
PrefabLibraryHeader plh;
|
||
|
|
plh.dwNumEntries = Prefabs.GetCount();
|
||
|
|
plh.fVersion = fLibVersion;
|
||
|
|
strcpy(plh.szNotes, szNotes);
|
||
|
|
file.write((char*)&plh, sizeof plh);
|
||
|
|
|
||
|
|
// allocate memory for directory
|
||
|
|
PrefabHeader *ph = new PrefabHeader[plh.dwNumEntries];
|
||
|
|
int iCur = 0;
|
||
|
|
|
||
|
|
char *pCopyBuf = new char[64000];
|
||
|
|
|
||
|
|
// write each prefab
|
||
|
|
POSITION p = Prefabs.GetHeadPosition();
|
||
|
|
while (p)
|
||
|
|
{
|
||
|
|
CPrefabRMF *pPrefab = (CPrefabRMF *)Prefabs.GetNext(p);
|
||
|
|
|
||
|
|
// setup this dir entry
|
||
|
|
ph[iCur].dwOffset = file.tellp();
|
||
|
|
V_strcpy_safe( ph[iCur].szName, pPrefab->GetName() );
|
||
|
|
V_strcpy_safe( ph[iCur].szNotes, pPrefab->GetNotes() );
|
||
|
|
ph[iCur].iType = pPrefab->GetType();
|
||
|
|
|
||
|
|
if(pPrefab->IsLoaded())
|
||
|
|
{
|
||
|
|
// it's loaded - save in native method
|
||
|
|
pPrefab->Save(file, CPrefab::lsUpdateFilePos);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// it's not loaded - save with quick method by copying
|
||
|
|
// bytes directly from the existing file
|
||
|
|
Assert(m_file.is_open());
|
||
|
|
m_file.seekg(pPrefab->dwFileOffset);
|
||
|
|
DWORD dwToRead = 64000, dwCopied = 0;
|
||
|
|
while(dwToRead == 64000)
|
||
|
|
{
|
||
|
|
if(dwCopied + dwToRead > pPrefab->dwFileSize)
|
||
|
|
dwToRead = pPrefab->dwFileSize - dwCopied;
|
||
|
|
m_file.read(pCopyBuf, dwToRead);
|
||
|
|
file.write(pCopyBuf, dwToRead);
|
||
|
|
dwCopied += dwToRead;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// set offset info HERE because we might use it above
|
||
|
|
pPrefab->dwFileOffset = ph[iCur].dwOffset;
|
||
|
|
|
||
|
|
// set size info
|
||
|
|
ph[iCur].dwSize = pPrefab->dwFileSize =
|
||
|
|
file.tellp() - (std::streamoff)ph[iCur].dwOffset;
|
||
|
|
|
||
|
|
++iCur; // increase current directory entry
|
||
|
|
}
|
||
|
|
|
||
|
|
// delete copy buf
|
||
|
|
delete[] pCopyBuf;
|
||
|
|
|
||
|
|
// rewrite binary header
|
||
|
|
plh.dwDirOffset = m_dwDirOffset = file.tellp();
|
||
|
|
file.seekp(dwBinaryHeaderOffset);
|
||
|
|
file.write((char*)&plh, sizeof(plh));
|
||
|
|
file.seekp(0, std::ios::end);
|
||
|
|
|
||
|
|
// write directory
|
||
|
|
file.write((char*)ph, sizeof(*ph) * plh.dwNumEntries);
|
||
|
|
file.close(); // close temp file
|
||
|
|
|
||
|
|
// delete original and rename
|
||
|
|
m_file.close(); // might already be open.. might not.
|
||
|
|
remove(m_strOpenFileName);
|
||
|
|
|
||
|
|
m_strOpenFileName = szFile;
|
||
|
|
rename(strTempFileName, m_strOpenFileName);
|
||
|
|
|
||
|
|
// reopen original
|
||
|
|
m_file.open(m_strOpenFileName, std::ios::in | std::ios::binary);
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: A library's name is based on its filename. We set the name here
|
||
|
|
// and rename the file if it exists, then re-open it.
|
||
|
|
// Input : pszName -
|
||
|
|
// Output : Returns zero on error, nonzero on success.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryRMF::SetName(LPCTSTR pszName)
|
||
|
|
{
|
||
|
|
// set szName
|
||
|
|
strcpy(m_szName, pszName);
|
||
|
|
|
||
|
|
char szNewFilename[MAX_PATH];
|
||
|
|
CHammer *pApp = (CHammer*) AfxGetApp();
|
||
|
|
pApp->GetDirectory(DIR_PREFABS, szNewFilename);
|
||
|
|
|
||
|
|
sprintf(szNewFilename + strlen(szNewFilename), "\\%s.ol", pszName);
|
||
|
|
|
||
|
|
if(m_file.is_open())
|
||
|
|
{
|
||
|
|
// close it -
|
||
|
|
m_file.close();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// ensure destination name doesn't exist already -
|
||
|
|
if(GetFileAttributes(szNewFilename) != 0xFFFFFFFF)
|
||
|
|
return 0; // exists.
|
||
|
|
}
|
||
|
|
|
||
|
|
// rename and reopen
|
||
|
|
rename(m_strOpenFileName, szNewFilename);
|
||
|
|
m_strOpenFileName = szNewFilename;
|
||
|
|
m_file.open(m_strOpenFileName, std::ios::in | std::ios::binary);
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibraryVMF::CPrefabLibraryVMF()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CPrefabLibraryVMF::~CPrefabLibraryVMF()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Returns true if this prefab represents the given filename, false if not.
|
||
|
|
// Input : szFilename - Path of a prefab library or folder.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CPrefabLibraryVMF::IsFile(const char *szFilename)
|
||
|
|
{
|
||
|
|
return(strcmpi(m_szFolderName, szFilename) == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// Output : int
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryVMF::Load(LPCTSTR pszFilename)
|
||
|
|
{
|
||
|
|
FreePrefabs();
|
||
|
|
|
||
|
|
SetNameFromFilename(pszFilename);
|
||
|
|
strcpy(m_szFolderName, pszFilename);
|
||
|
|
|
||
|
|
m_eType = LibType_HalfLife2;
|
||
|
|
|
||
|
|
// dvs: new prefab libs have no notes! who cares?
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read the prefabs - they are stored as individual VMF files.
|
||
|
|
//
|
||
|
|
char szDir[MAX_PATH];
|
||
|
|
strcpy(szDir, pszFilename);
|
||
|
|
strcat(szDir, "\\*.vmf");
|
||
|
|
|
||
|
|
WIN32_FIND_DATA fd;
|
||
|
|
HANDLE hnd = FindFirstFile(szDir, &fd);
|
||
|
|
if (hnd == INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
// No prefabs in this folder.
|
||
|
|
return(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
*strrchr(szDir, '*') = '\0';
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if (fd.cFileName[0] != '.')
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Build the full path to the prefab file.
|
||
|
|
//
|
||
|
|
char szFile[MAX_PATH];
|
||
|
|
strcpy(szFile, szDir);
|
||
|
|
strcat(szFile, fd.cFileName);
|
||
|
|
|
||
|
|
CPrefabVMF *pPrefab = new CPrefabVMF;
|
||
|
|
pPrefab->SetFilename(szFile);
|
||
|
|
|
||
|
|
Add(pPrefab);
|
||
|
|
}
|
||
|
|
} while (FindNextFile(hnd, &fd));
|
||
|
|
|
||
|
|
FindClose(hnd);
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Removes this prefab library from disk.
|
||
|
|
// Output : Returns true on success, false on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CPrefabLibraryVMF::DeleteFile(void)
|
||
|
|
{
|
||
|
|
// dvs: can't remove the prefab folder yet
|
||
|
|
return(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszFilename -
|
||
|
|
// bIndexOnly -
|
||
|
|
// Output : int
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryVMF::Save(LPCTSTR pszFilename, BOOL bIndexOnly)
|
||
|
|
{
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Set's the library's name by renaming the folder.
|
||
|
|
// Input : pszName -
|
||
|
|
// Output : Returns zero on error, nonzero on success.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
int CPrefabLibraryVMF::SetName(LPCTSTR pszName)
|
||
|
|
{
|
||
|
|
// dvs: rename the folder - or maybe don't implement for VMF prefabs
|
||
|
|
strcpy(m_szName, pszName);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|