778 lines
23 KiB
C++
778 lines
23 KiB
C++
|
#include "scene/DataFileMgr.h"
|
||
|
|
#include "scene/DataFileMgr_parser.h"
|
||
|
|
|
||
|
|
// Rage headers
|
||
|
|
#include "fwsys/fileExts.h"
|
||
|
|
#include "parser/manager.h"
|
||
|
|
#include "parsercore/stream.h"
|
||
|
|
#include "streaming/streamingengine.h"
|
||
|
|
#include "streaming/streaminginfo.h"
|
||
|
|
#include "streaming/streamingmodule.h"
|
||
|
|
#include "streaming/streamingmodulemgr.h"
|
||
|
|
#include "string/stringutil.h"
|
||
|
|
#include "system/param.h"
|
||
|
|
#include "system/platform.h"
|
||
|
|
#include "system/nelem.h"
|
||
|
|
#include "scene/dlc_channel.h"
|
||
|
|
#include "scene/ExtraContent.h"
|
||
|
|
#include "scene/scene.h"
|
||
|
|
#include "control/leveldata.h"
|
||
|
|
#include "control/gamelogic.h"
|
||
|
|
#include "file/device_relative.h"
|
||
|
|
|
||
|
|
eDFMI_UnloadType CDataFileMount::sm_UnloadBehaviours[CDataFileMgr::INVALID_FILE];
|
||
|
|
atRangeArray<CDataFileMountInterface *, CDataFileMgr::INVALID_FILE> CDataFileMount::sm_Interfaces;
|
||
|
|
bool CDataFileMount::sm_overrideUnload = true;
|
||
|
|
eDFMI_UnloadType CDataFileMount::sm_unloadBehaviour = eDFMI_UnloadDefault;
|
||
|
|
|
||
|
|
XPARAM(usefatcuts);
|
||
|
|
|
||
|
|
bool CDataFileMgr::ChangeSetData::IsValid(bool executing) const
|
||
|
|
{
|
||
|
|
bool returnValue = true;
|
||
|
|
|
||
|
|
// Check if this changeset has any map associations
|
||
|
|
if (m_associatedMap.length() > 0)
|
||
|
|
{
|
||
|
|
s32 currLevelIdx = CGameLogic::GetCurrentLevelIndex();
|
||
|
|
s32 reqLevelIdx = CGameLogic::GetRequestedLevelIndex();
|
||
|
|
s32 associatedMapIdx = CScene::GetLevelsData().GetLevelIndexFromTitleName(m_associatedMap.c_str());
|
||
|
|
|
||
|
|
// If there's no transition just check for association
|
||
|
|
if (currLevelIdx == reqLevelIdx)
|
||
|
|
returnValue = associatedMapIdx == currLevelIdx;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// There's some form of transition, only allow changes for the current map to be reverted
|
||
|
|
if (associatedMapIdx == currLevelIdx)
|
||
|
|
returnValue = !executing;
|
||
|
|
else
|
||
|
|
returnValue = associatedMapIdx == reqLevelIdx;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!returnValue)
|
||
|
|
{
|
||
|
|
NOTFINAL_ONLY(Displayf("ChangeSetData::IsValid - change set is not valid due to map association with [%s] [%s]",
|
||
|
|
m_associatedMap.c_str(), CScene::GetLevelsData().GetFriendlyName(associatedMapIdx));)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return returnValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
strIndex CDataFileMgr::ResourceReference::Resolve() const
|
||
|
|
{
|
||
|
|
// Get the module first.
|
||
|
|
char extension[sizeof(m_Extension)];
|
||
|
|
|
||
|
|
memcpy(extension, m_Extension, sizeof(m_Extension));
|
||
|
|
|
||
|
|
if (extension[0] == '#')
|
||
|
|
{
|
||
|
|
extension[0] = g_sysPlatform;
|
||
|
|
}
|
||
|
|
|
||
|
|
strStreamingModule *module = strStreamingEngine::GetInfo().GetModuleMgr().GetModuleFromFileExtension(extension);
|
||
|
|
|
||
|
|
if (module)
|
||
|
|
{
|
||
|
|
strLocalIndex slot = module->FindSlot(m_AssetName.c_str());
|
||
|
|
|
||
|
|
if (slot != -1)
|
||
|
|
{
|
||
|
|
return module->GetStreamingIndex(slot);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Assertf(false, "Unable to resolve %s.%s", m_AssetName.c_str(), m_Extension);
|
||
|
|
return strIndex();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
CDataFileMgr::CDataFileMgr()
|
||
|
|
{
|
||
|
|
// Set up the environment variables.
|
||
|
|
m_EnvVariableMap.Insert(ATSTRINGHASH("PLATFORM", 0x02fbe482d), ConstString(RSG_PLATFORM_ID));
|
||
|
|
m_addingPatchFiles = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if __BANK
|
||
|
|
bool CDataFileMgr::GetFatcuts()
|
||
|
|
{
|
||
|
|
return PARAM_usefatcuts.Get();
|
||
|
|
}
|
||
|
|
#endif // __BANK
|
||
|
|
|
||
|
|
FASTRETURNCHECK(const char *) CDataFileMgr::RemapDataFileName(const char *origFile, char *NOTFINAL_ONLY(outTargetBuffer), size_t NOTFINAL_ONLY(targetBufferSize))
|
||
|
|
{
|
||
|
|
#if !__FINAL
|
||
|
|
if (PARAM_usefatcuts.Get())
|
||
|
|
{
|
||
|
|
const char *filename = ASSET.FileName(origFile);
|
||
|
|
size_t string_length_of_path = filename - origFile;
|
||
|
|
|
||
|
|
if (PARAM_usefatcuts.Get())
|
||
|
|
{
|
||
|
|
Displayf("Testing %s", filename);
|
||
|
|
if (stricmp(filename, "common_cutscene.meta") == 0)
|
||
|
|
{
|
||
|
|
memcpy(outTargetBuffer, origFile, Min(string_length_of_path, targetBufferSize));
|
||
|
|
outTargetBuffer[Min(string_length_of_path, targetBufferSize)] = 0;
|
||
|
|
safecat(outTargetBuffer, "/", targetBufferSize);
|
||
|
|
safecat(outTargetBuffer, "common_cutscene_fat.meta", targetBufferSize);
|
||
|
|
|
||
|
|
return outTargetBuffer;
|
||
|
|
}
|
||
|
|
else if (stricmp(filename, "cuts.meta") == 0)
|
||
|
|
{
|
||
|
|
memcpy(outTargetBuffer, origFile, Min(string_length_of_path, targetBufferSize));
|
||
|
|
outTargetBuffer[Min(string_length_of_path, targetBufferSize)] = 0;
|
||
|
|
safecat(outTargetBuffer, "/", targetBufferSize);
|
||
|
|
safecat(outTargetBuffer, "cuts_fat.meta", targetBufferSize);
|
||
|
|
|
||
|
|
return outTargetBuffer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // !__FINAL
|
||
|
|
|
||
|
|
return origFile;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if __ASSERT
|
||
|
|
void CDataFileMgr::VerifyXmlContents(ContentsOfDataFileXml& XmlContents, const char* pFilename) const
|
||
|
|
{
|
||
|
|
// Fill temporary array with change sets' enabled and disabled files.
|
||
|
|
atArray<const char*> tempArray;
|
||
|
|
for(int j=0; j<XmlContents.m_contentChangeSets.GetCount(); ++j)
|
||
|
|
{
|
||
|
|
const ContentChangeSet* pChangeSet = &(XmlContents.m_contentChangeSets[j]);
|
||
|
|
for(int i=0; i<pChangeSet->m_filesToEnable.GetCount(); ++i)
|
||
|
|
{
|
||
|
|
tempArray.PushAndGrow(pChangeSet->m_filesToEnable[i].c_str());
|
||
|
|
}
|
||
|
|
for(int i=0; i<pChangeSet->m_filesToDisable.GetCount(); ++i)
|
||
|
|
{
|
||
|
|
tempArray.PushAndGrow(pChangeSet->m_filesToDisable[i].c_str());
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int k=0; k<pChangeSet->m_mapChangeSetData.GetCount(); ++k)
|
||
|
|
{
|
||
|
|
const ChangeSetData* pData = &(pChangeSet->m_mapChangeSetData[k]);
|
||
|
|
for(int i=0; i<pData->m_filesToEnable.GetCount(); ++i)
|
||
|
|
{
|
||
|
|
tempArray.PushAndGrow(pData->m_filesToEnable[i].c_str());
|
||
|
|
}
|
||
|
|
for(int i=0; i<pChangeSet->m_mapChangeSetData[k].m_filesToDisable.GetCount(); ++i)
|
||
|
|
{
|
||
|
|
tempArray.PushAndGrow(pData->m_filesToDisable[i].c_str());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for actual data file dupes. Let's hope not.
|
||
|
|
for (int i = 0; i < XmlContents.m_dataFiles.GetCount(); ++i) {
|
||
|
|
for (int j = i+1; j < XmlContents.m_dataFiles.GetCount(); ++j) {
|
||
|
|
bool bFilesMatch = (strnicmp(XmlContents.m_dataFiles[i].m_filename, XmlContents.m_dataFiles[j].m_filename, 128) == 0);
|
||
|
|
Assertf(!bFilesMatch, "Duplicate data file '%s' in file '%s' (indices %i and %i)", XmlContents.m_dataFiles[i].m_filename, pFilename, i, j);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if content.xml belongs to DLC device or title update.
|
||
|
|
bool isDLCorUpdate = ( !strnicmp(pFilename, "DLC", 3) || !strnicmp(pFilename, "update", 6) );
|
||
|
|
if(isDLCorUpdate)
|
||
|
|
{
|
||
|
|
// Automatically add the content.xml's folder to allowed ones.
|
||
|
|
AddDefaultAllowedFolders(XmlContents, pFilename);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check the temporary array for issues.
|
||
|
|
for(int i=0; i<tempArray.GetCount(); ++i)
|
||
|
|
{
|
||
|
|
// Disallowed folders.
|
||
|
|
if(XmlContents.m_allowedFolders.GetCount() && isDLCorUpdate)
|
||
|
|
{
|
||
|
|
Verifyf(IsInAllowedFolder(XmlContents, tempArray[i]), "Data file %s is not placed in one of the allowed folders", tempArray[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate entries.
|
||
|
|
for(int j=i+1; j<tempArray.GetCount(); ++j)
|
||
|
|
{
|
||
|
|
if(!Verifyf(strcmp(tempArray[i], tempArray[j]), "Duplicate entry of %s found in %s.", tempArray[i], pFilename))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::AddDefaultAllowedFolders(ContentsOfDataFileXml& XmlContents, const char* pFilename) const
|
||
|
|
{
|
||
|
|
if(const char* pChar = stristr(pFilename, ":")){
|
||
|
|
atString &pStr = XmlContents.m_allowedFolders.Grow();
|
||
|
|
pStr.Set(pFilename, RAGE_MAX_PATH, 0, static_cast<int>(pChar-pFilename)+1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(const char* pChar = stristr(pFilename, "CRC:"))
|
||
|
|
{
|
||
|
|
atString &pStr = XmlContents.m_allowedFolders.Grow();
|
||
|
|
pStr.Set(pFilename, RAGE_MAX_PATH, 0, static_cast<int>(pChar-pFilename));
|
||
|
|
pStr += ":";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CDataFileMgr::IsInAllowedFolder(const ContentsOfDataFileXml& XmlContents, const char* filePath) const
|
||
|
|
{
|
||
|
|
// If there are no specified folders then assume the file is setup correctly (for backwards compatibility)
|
||
|
|
if(XmlContents.m_allowedFolders.empty())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if file lies within specified folders.
|
||
|
|
for(int k=0; k<XmlContents.m_allowedFolders.GetCount(); ++k)
|
||
|
|
{
|
||
|
|
if( !strnicmp(XmlContents.m_allowedFolders[k].c_str(), filePath, XmlContents.m_allowedFolders[k].GetLength()) )
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CDataFileMgr::CheckCRCValidity(const DataFile* dataFile)
|
||
|
|
{
|
||
|
|
const DataFile* pFile = DATAFILEMGR.GetFirstFile(dataFile->m_fileType);
|
||
|
|
if( !strnicmp(pFile->m_filename, "commoncrc:", 10) && !strnicmp(dataFile->m_filename, "dlc", 3) )
|
||
|
|
{
|
||
|
|
char device[RAGE_MAX_PATH] = {0};
|
||
|
|
strncpy(device, dataFile->m_filename, static_cast<int>(strcspn(dataFile->m_filename, "/")) + 1);
|
||
|
|
bool isCompatPack = EXTRACONTENT.GetContentByDevice(device)->GetIsCompatibilityPack();
|
||
|
|
if(!stristr(dataFile->m_filename, "CRC:") && isCompatPack)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
#endif // __ASSERT
|
||
|
|
|
||
|
|
void CDataFileMgr::Load(const char *pFilename, bool bCullOtherPlatformData /*= true*/)
|
||
|
|
{
|
||
|
|
ContentsOfDataFileXml XmlContents;
|
||
|
|
|
||
|
|
char FilenameWithoutExtension[256];
|
||
|
|
ASSET.RemoveExtensionFromPath(FilenameWithoutExtension, 256, pFilename);
|
||
|
|
|
||
|
|
parSettings s = PARSER.Settings();
|
||
|
|
s.SetFlag(parSettings::CULL_OTHER_PLATFORM_DATA, bCullOtherPlatformData);
|
||
|
|
//@@: location CDATAFILEMGR_LOAD_META_EXISTS
|
||
|
|
if (ASSET.Exists(FilenameWithoutExtension, "meta"))
|
||
|
|
{
|
||
|
|
PARSER.LoadObject(FilenameWithoutExtension, "meta", XmlContents, &s);
|
||
|
|
}
|
||
|
|
else if (ASSET.Exists(pFilename, META_FILE_EXT))
|
||
|
|
{
|
||
|
|
Verifyf(fwPsoStoreLoader::LoadDataIntoObject(pFilename, META_FILE_EXT, XmlContents), "Failed to load %s", pFilename);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
PARSER.LoadObject(FilenameWithoutExtension, "xml", XmlContents, &s);
|
||
|
|
}
|
||
|
|
|
||
|
|
#if __ASSERT
|
||
|
|
// Check contents of content.xml for errors.
|
||
|
|
VerifyXmlContents(XmlContents, pFilename);
|
||
|
|
#endif // __ASSERT
|
||
|
|
|
||
|
|
for(int i=0;i<XmlContents.m_dataFiles.GetCount();i++)
|
||
|
|
{
|
||
|
|
const char* currentFile = XmlContents.m_dataFiles[i].m_filename;
|
||
|
|
//First check if this file should get replaced (ptfx/script/fatcuts etc)
|
||
|
|
char replacementPath[RAGE_MAX_PATH];
|
||
|
|
if(CFileLoader::CheckFileForReplacements(currentFile,replacementPath,RAGE_MAX_PATH))
|
||
|
|
{
|
||
|
|
Displayf("Changing %s",XmlContents.m_dataFiles[i].m_filename);
|
||
|
|
strcpy(XmlContents.m_dataFiles[i].m_filename,replacementPath);
|
||
|
|
Displayf("to %s",XmlContents.m_dataFiles[i].m_filename);
|
||
|
|
}
|
||
|
|
if(!fiDevice::CheckFileValidity(currentFile))
|
||
|
|
{
|
||
|
|
//Delete invalid files
|
||
|
|
Assertf(false,"invalid devicename in the datafile %s",currentFile);
|
||
|
|
XmlContents.m_dataFiles.Delete(i);
|
||
|
|
i--;
|
||
|
|
}
|
||
|
|
// Check if DLC files are properly CRC'd.
|
||
|
|
Assertf(CheckCRCValidity(&(XmlContents.m_dataFiles[i])), "%s in %s should be CRC'd but is not!", XmlContents.m_dataFiles[i].m_filename, pFilename);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for any collisions between CCSs
|
||
|
|
for (int x = 0; x < XmlContents.m_contentChangeSets.GetCount(); x++)
|
||
|
|
{
|
||
|
|
ContentChangeSet& changeSet = XmlContents.m_contentChangeSets[x];
|
||
|
|
|
||
|
|
// If we have a collision we cache the collider, remove all its files from this content XML data preserving any other non colliding CCSs
|
||
|
|
ContentChangeSet* higherOrderCCS = m_contentChangeSets.Access(changeSet.m_changeSetName.c_str());
|
||
|
|
if (higherOrderCCS)
|
||
|
|
{
|
||
|
|
#if !__FINAL
|
||
|
|
// If we have a collision verify that the files identical between the two CCSs
|
||
|
|
if (higherOrderCCS->m_filesToEnable.GetCount() == changeSet.m_filesToEnable.GetCount())
|
||
|
|
{
|
||
|
|
char highOrderFile[256] = { 0 };
|
||
|
|
char lowOrderFile[256] = { 0 };
|
||
|
|
char* highOrderFileNoDevice = NULL;
|
||
|
|
char* lowOrderFileNoDevice = NULL;
|
||
|
|
|
||
|
|
for (u32 i = 0; i < higherOrderCCS->m_filesToEnable.GetCount(); i++)
|
||
|
|
{
|
||
|
|
formatf(highOrderFile, sizeof(highOrderFile), "%s", higherOrderCCS->m_filesToEnable[i].c_str());
|
||
|
|
formatf(lowOrderFile, sizeof(lowOrderFile), "%s", changeSet.m_filesToEnable[i].c_str());
|
||
|
|
|
||
|
|
highOrderFileNoDevice = strstr(highOrderFile, ":/");
|
||
|
|
lowOrderFileNoDevice = strstr(lowOrderFile, ":/");
|
||
|
|
|
||
|
|
if (strcmp(highOrderFileNoDevice, lowOrderFileNoDevice) != 0)
|
||
|
|
{
|
||
|
|
Assertf(0, "CDataFileMgr::Load - %s CCSs Collide but they are not identical, check order of files! [%s vs %s]",
|
||
|
|
changeSet.m_changeSetName.c_str(), highOrderFileNoDevice, lowOrderFileNoDevice);
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Assertf(0, "CDataFileMgr::Load - %s CCSs Collide but they are not identical, check file counts! [%i vs %i]",
|
||
|
|
changeSet.m_changeSetName.c_str(), higherOrderCCS->m_filesToEnable.GetCount(), changeSet.m_filesToEnable.GetCount());
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
atHashString newCollision = changeSet.m_changeSetName.c_str();
|
||
|
|
|
||
|
|
dlcDebugf3("CDataFileMgr::Load - There is a collision between CCSs [%s]", changeSet.m_changeSetName.c_str());
|
||
|
|
|
||
|
|
m_changeSetCollisions.PushAndGrow(newCollision, 1);
|
||
|
|
|
||
|
|
for (u32 i = 0; i < changeSet.m_filesToEnable.GetCount(); i++)
|
||
|
|
{
|
||
|
|
for (u32 j = 0; j < XmlContents.m_dataFiles.GetCount(); j++)
|
||
|
|
{
|
||
|
|
if (strcmp(XmlContents.m_dataFiles[j].m_filename, changeSet.m_filesToEnable[i].c_str()) == 0)
|
||
|
|
{
|
||
|
|
dlcDebugf3("CDataFileMgr::Load - Deleting file reference [%s]", XmlContents.m_dataFiles[j].m_filename);
|
||
|
|
|
||
|
|
XmlContents.m_dataFiles.Delete(j);
|
||
|
|
j--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
XmlContents.m_contentChangeSets.DeleteFast(x);
|
||
|
|
x--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
s32 index = 0;
|
||
|
|
const s32 numOfDisabledFiles = XmlContents.m_disabledFiles.GetCount();
|
||
|
|
while(index < numOfDisabledFiles)
|
||
|
|
{
|
||
|
|
// Printf("CDataFileMgr::Load - index = %d disabled_filename = %s\n", index, XmlContents.m_disabledFiles[index].c_str());
|
||
|
|
AddDisabledFile(XmlContents.m_disabledFiles[index].c_str());
|
||
|
|
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
const s32 numOfIncludedDataFiles = XmlContents.m_includedDataFiles.GetCount();
|
||
|
|
for (int x=0; x<numOfIncludedDataFiles; x++)
|
||
|
|
{
|
||
|
|
char fileBuffer[RAGE_MAX_PATH];
|
||
|
|
const char *dataFileName = XmlContents.m_includedDataFiles[x].c_str();
|
||
|
|
const char *mappedDataFile = RemapDataFileName(dataFileName, fileBuffer, sizeof(fileBuffer));
|
||
|
|
Load(mappedDataFile);
|
||
|
|
}
|
||
|
|
|
||
|
|
s32 xml_file_index = 0;
|
||
|
|
//@@: location CDATAFILEMGR_LOAD_GET_XML_COUNT
|
||
|
|
const s32 numOfIncludedXmlFiles = XmlContents.m_includedXmlFiles.GetCount();
|
||
|
|
while(xml_file_index < numOfIncludedXmlFiles)
|
||
|
|
{
|
||
|
|
index = 0;
|
||
|
|
const s32 numOfDataFilesInThisXmlFile = XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles.GetCount();
|
||
|
|
while (index < numOfDataFilesInThisXmlFile)
|
||
|
|
{
|
||
|
|
//Printf("CDataFileMgr::Load (included xml) - index = %d filetype = %d filename = %s\n", index, XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles[index].m_fileType,
|
||
|
|
// XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles[index].m_filename);
|
||
|
|
|
||
|
|
|
||
|
|
const DataFile &dataFile = XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles[index];
|
||
|
|
AddFile(dataFile,pFilename);
|
||
|
|
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
xml_file_index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
index = 0;
|
||
|
|
const s32 numOfDataFiles = XmlContents.m_dataFiles.GetCount();
|
||
|
|
while(index < numOfDataFiles)
|
||
|
|
{
|
||
|
|
//Printf("CDataFileMgr::Load - index = %d filetype = %d filename = %s\n", index, XmlContents.m_dataFiles[index].m_fileType,
|
||
|
|
// XmlContents.m_dataFiles[index].m_filename);
|
||
|
|
|
||
|
|
AddFile(XmlContents.m_dataFiles[index],pFilename);
|
||
|
|
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int x=0; x<XmlContents.m_contentChangeSets.GetCount(); x++)
|
||
|
|
{
|
||
|
|
ContentChangeSet &changeSet = XmlContents.m_contentChangeSets[x];
|
||
|
|
for(int y=0;y<changeSet.m_filesToEnable.GetCount();y++)
|
||
|
|
{
|
||
|
|
const char* currentFile = changeSet.m_filesToEnable[y].c_str();
|
||
|
|
char replacementPath[RAGE_MAX_PATH];
|
||
|
|
if(CFileLoader::CheckFileForReplacements(currentFile,replacementPath,RAGE_MAX_PATH))
|
||
|
|
{
|
||
|
|
Displayf("Changing %s",changeSet.m_filesToEnable[y].c_str());
|
||
|
|
changeSet.m_filesToEnable[y].Set(replacementPath,RAGE_MAX_PATH,0);
|
||
|
|
Displayf("to %s",changeSet.m_filesToEnable[y].c_str());
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
m_contentChangeSets[changeSet.m_changeSetName.c_str()] = changeSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
const s32 numOfPatchFiles = XmlContents.m_patchFiles.GetCount();
|
||
|
|
for (int x = 0; x < numOfPatchFiles; x++)
|
||
|
|
{
|
||
|
|
const char* patchFileName = XmlContents.m_patchFiles[x].c_str();
|
||
|
|
PARSER.AddPatchFileToList(patchFileName);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::GetCCSArchivesToEnable(atHashString changeSetName, bool execute, atMap<s32, bool>& archives)
|
||
|
|
{
|
||
|
|
if (ContentChangeSet* ccs = m_contentChangeSets.Access(changeSetName))
|
||
|
|
{
|
||
|
|
s32 imgIdx = -1;
|
||
|
|
char expandedFilename[RAGE_MAX_PATH] = { 0 };
|
||
|
|
|
||
|
|
for (s32 i = 0; i < ccs->m_filesToEnable.GetCount(); i++)
|
||
|
|
{
|
||
|
|
DATAFILEMGR.ExpandFilename(ccs->m_filesToEnable[i].c_str(), expandedFilename, sizeof(expandedFilename));
|
||
|
|
imgIdx = strPackfileManager::FindImage(expandedFilename);
|
||
|
|
|
||
|
|
if (imgIdx != -1 && archives.Access(imgIdx) == NULL)
|
||
|
|
archives.Insert(imgIdx, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (s32 i = 0; i < ccs->m_mapChangeSetData.GetCount(); i++)
|
||
|
|
{
|
||
|
|
ChangeSetData& currData = ccs->m_mapChangeSetData[i];
|
||
|
|
|
||
|
|
if (currData.IsValid(execute))
|
||
|
|
{
|
||
|
|
for (s32 j = 0; j < currData.m_filesToEnable.GetCount(); j++)
|
||
|
|
{
|
||
|
|
DATAFILEMGR.ExpandFilename(currData.m_filesToEnable[j].c_str(), expandedFilename, sizeof(expandedFilename));
|
||
|
|
imgIdx = strPackfileManager::FindImage(expandedFilename);
|
||
|
|
|
||
|
|
if (imgIdx != -1 && archives.Access(imgIdx) == NULL)
|
||
|
|
archives.Insert(imgIdx, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::DestroyDependentsGraph()
|
||
|
|
{
|
||
|
|
strStreamingEngine::GetInfo().DestroyDependentGraphs();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::CreateDependentsGraph(atHashString changeSetName, bool execute)
|
||
|
|
{
|
||
|
|
if (ContentChangeSet* ccs = m_contentChangeSets.Access(changeSetName))
|
||
|
|
{
|
||
|
|
atArray<s32> filesToEnableCache;
|
||
|
|
atArray<s32> filesToInvalidateCache;
|
||
|
|
s32 imgIdx = -1;
|
||
|
|
char expandedFilename[RAGE_MAX_PATH] = { 0 };
|
||
|
|
|
||
|
|
for (s32 i = 0; i < ccs->m_mapChangeSetData.GetCount(); i++)
|
||
|
|
{
|
||
|
|
ChangeSetData& currData = ccs->m_mapChangeSetData[i];
|
||
|
|
|
||
|
|
if (currData.IsValid(execute))
|
||
|
|
{
|
||
|
|
for (s32 j = 0; j < currData.m_filesToEnable.GetCount(); j++)
|
||
|
|
{
|
||
|
|
DATAFILEMGR.ExpandFilename(currData.m_filesToEnable[j].c_str(), expandedFilename, sizeof(expandedFilename));
|
||
|
|
imgIdx = strPackfileManager::FindImage(expandedFilename);
|
||
|
|
|
||
|
|
if (imgIdx != -1)
|
||
|
|
{
|
||
|
|
filesToEnableCache.PushAndGrow(imgIdx, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (s32 j = 0; j < currData.m_filesToInvalidate.GetCount(); j++)
|
||
|
|
{
|
||
|
|
DATAFILEMGR.ExpandFilename(currData.m_filesToInvalidate[j].c_str(), expandedFilename, sizeof(expandedFilename));
|
||
|
|
imgIdx = strPackfileManager::FindImage(expandedFilename);
|
||
|
|
|
||
|
|
if (imgIdx != -1)
|
||
|
|
{
|
||
|
|
if (const atArray<s32>* associatedFiles = strStreamingEngine::GetInfo().GetPackfileRelationships(imgIdx))
|
||
|
|
{
|
||
|
|
for (s32 k = 0; k < associatedFiles->GetCount(); k++)
|
||
|
|
{
|
||
|
|
imgIdx = (*associatedFiles)[k];
|
||
|
|
|
||
|
|
if (imgIdx != -1)
|
||
|
|
filesToInvalidateCache.PushAndGrow(imgIdx, (u16)associatedFiles->GetCount());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
filesToInvalidateCache.PushAndGrow(imgIdx, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
strStreamingEngine::GetInfo().CreateDependentsGraph(filesToEnableCache);
|
||
|
|
strStreamingEngine::GetInfo().CreateDependentsGraph(filesToInvalidateCache);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::Unload(const char *pFilename, bool bCullOtherPlatformData /*= true*/)
|
||
|
|
{
|
||
|
|
ContentsOfDataFileXml XmlContents;
|
||
|
|
|
||
|
|
char FilenameWithoutExtension[256];
|
||
|
|
ASSET.RemoveExtensionFromPath(FilenameWithoutExtension, 256, pFilename);
|
||
|
|
|
||
|
|
parSettings s = PARSER.Settings();
|
||
|
|
s.SetFlag(parSettings::CULL_OTHER_PLATFORM_DATA, bCullOtherPlatformData);
|
||
|
|
|
||
|
|
if (ASSET.Exists(FilenameWithoutExtension, "meta"))
|
||
|
|
PARSER.LoadObject(FilenameWithoutExtension, "meta", XmlContents, &s);
|
||
|
|
else
|
||
|
|
PARSER.LoadObject(FilenameWithoutExtension, "xml", XmlContents, &s);
|
||
|
|
|
||
|
|
s32 index = 0;
|
||
|
|
const s32 numOfDisabledFiles = XmlContents.m_disabledFiles.GetCount();
|
||
|
|
while(index < numOfDisabledFiles)
|
||
|
|
{
|
||
|
|
RemoveDisabledFile(XmlContents.m_disabledFiles[index].c_str());
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
index = 0;
|
||
|
|
const s32 numOfDataFiles = XmlContents.m_dataFiles.GetCount();
|
||
|
|
while(index < numOfDataFiles)
|
||
|
|
{
|
||
|
|
RemoveFile(XmlContents.m_dataFiles[index].m_filename);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
s32 xml_file_index = 0;
|
||
|
|
const s32 numOfIncludedXmlFiles = XmlContents.m_includedXmlFiles.GetCount();
|
||
|
|
while(xml_file_index < numOfIncludedXmlFiles)
|
||
|
|
{
|
||
|
|
index = 0;
|
||
|
|
const s32 numOfDataFilesInThisXmlFile = XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles.GetCount();
|
||
|
|
while (index < numOfDataFilesInThisXmlFile)
|
||
|
|
{
|
||
|
|
const DataFile &dataFile = XmlContents.m_includedXmlFiles[xml_file_index].m_dataFiles[index];
|
||
|
|
RemoveFile(dataFile.m_filename);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
xml_file_index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int x = 0; x < XmlContents.m_contentChangeSets.GetCount(); x++)
|
||
|
|
{
|
||
|
|
ContentChangeSet& changeSet = XmlContents.m_contentChangeSets[x];
|
||
|
|
|
||
|
|
m_contentChangeSets.Delete(changeSet.m_changeSetName.c_str());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const CDataFileMgr::ContentChangeSet *CDataFileMgr::GetContentChangeSet(atHashString contentChangeSetName) const
|
||
|
|
{
|
||
|
|
return m_contentChangeSets.Access(contentChangeSetName);
|
||
|
|
}
|
||
|
|
|
||
|
|
CDataFileMgr::DataFile *CDataFileMgr::FindDataFile(atHashString fileName)
|
||
|
|
{
|
||
|
|
int count = m_dataFiles.GetCount();
|
||
|
|
|
||
|
|
for (int x=0; x<count; x++)
|
||
|
|
{
|
||
|
|
if (fileName == m_dataFiles[x].m_filename)
|
||
|
|
{
|
||
|
|
return &m_dataFiles[x];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void CDataFileMgr::ExpandFilename(const char *filename, char *outBuffer, size_t bufferSize)
|
||
|
|
{
|
||
|
|
// Copy the string, and find all special characters on the way.
|
||
|
|
// We'll copy the string into the target buffer first, including the variables. As we'll
|
||
|
|
// encounter the end of a varible, we'll make use of the fact that it's null-terminated at
|
||
|
|
// that point so we can easily look it up and replace it.
|
||
|
|
char *lastVarBegin = NULL;
|
||
|
|
|
||
|
|
bufferSize--;
|
||
|
|
|
||
|
|
while (*filename && bufferSize > 0)
|
||
|
|
{
|
||
|
|
char chr = *(filename++);
|
||
|
|
|
||
|
|
if (chr != '%')
|
||
|
|
{
|
||
|
|
*(outBuffer++) = chr;
|
||
|
|
bufferSize--;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// This could be the beginning or end of a variable.
|
||
|
|
if (!lastVarBegin)
|
||
|
|
{
|
||
|
|
// It's the beginning of a variable.
|
||
|
|
lastVarBegin = outBuffer;
|
||
|
|
|
||
|
|
*(outBuffer++) = chr;
|
||
|
|
bufferSize--;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// It's the end of a variable. Let's look it up.
|
||
|
|
// If it's two % signs right after one another, let's assume the user intended to
|
||
|
|
// to escape a single % sign.
|
||
|
|
if (lastVarBegin + 1 != outBuffer)
|
||
|
|
{
|
||
|
|
// We still need to terminate the buffer, it could contain data if we previously expanded
|
||
|
|
// a longer variable name with a shorter string.
|
||
|
|
*outBuffer = 0;
|
||
|
|
|
||
|
|
ConstString *var = m_EnvVariableMap.Access(atStringHash(&lastVarBegin[1]));
|
||
|
|
|
||
|
|
// If this doesn't resolve to a variable, just leave the string untouched, as DOS would do.
|
||
|
|
if (var)
|
||
|
|
{
|
||
|
|
// It IS a proper variable, so replace it.
|
||
|
|
size_t varLength = strlen(var->c_str());
|
||
|
|
bufferSize += outBuffer - lastVarBegin;
|
||
|
|
strncpy(lastVarBegin, var->c_str(), bufferSize);
|
||
|
|
bufferSize = Max((size_t) 0, bufferSize - varLength);
|
||
|
|
outBuffer = lastVarBegin + varLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lastVarBegin = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*outBuffer = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::RemoveMapDataFiles()
|
||
|
|
{
|
||
|
|
atArray<DataFile> dataFilesToKeep;
|
||
|
|
|
||
|
|
s32 numberOfEntries = m_dataFiles.GetCount();
|
||
|
|
s32 loop = 0;
|
||
|
|
for (loop = 0; loop < numberOfEntries; loop++)
|
||
|
|
{
|
||
|
|
if (m_dataFiles[loop].m_persistent)
|
||
|
|
{
|
||
|
|
dataFilesToKeep.PushAndGrow(m_dataFiles[loop]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch (m_dataFiles[loop].m_fileType)
|
||
|
|
{
|
||
|
|
case RPF_FILE :
|
||
|
|
case IDE_FILE :
|
||
|
|
case DELAYED_IDE_FILE :
|
||
|
|
case IPL_FILE :
|
||
|
|
case PERMANENT_ITYP_FILE :
|
||
|
|
// don't copy these types across to dataFilesToKeep
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
dataFilesToKeep.PushAndGrow(m_dataFiles[loop]);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fix up the m_handle of all the entries in dataFilesToKeep
|
||
|
|
numberOfEntries = dataFilesToKeep.GetCount();
|
||
|
|
for (loop = 0; loop < numberOfEntries; loop++)
|
||
|
|
{
|
||
|
|
dataFilesToKeep[loop].m_handle = loop;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dataFiles.Reset();
|
||
|
|
m_dataFiles = dataFilesToKeep;
|
||
|
|
|
||
|
|
// Also clear the array of disabled files?
|
||
|
|
m_disabledFiles.Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::Clear()
|
||
|
|
{
|
||
|
|
m_dataFiles.Reset();
|
||
|
|
m_disabledFiles.Reset();
|
||
|
|
|
||
|
|
m_LockedFilesCount = 0;
|
||
|
|
m_LockedDisabledFilesCount = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::SnapshotFiles()
|
||
|
|
{
|
||
|
|
m_LockedFilesCount = m_dataFiles.GetCount();
|
||
|
|
m_LockedDisabledFilesCount = m_disabledFiles.GetCount();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CDataFileMgr::RecallSnapshot()
|
||
|
|
{
|
||
|
|
m_dataFiles.Resize(m_LockedFilesCount);
|
||
|
|
m_disabledFiles.Resize(m_LockedDisabledFilesCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
#if __BANK
|
||
|
|
void CDataFileMount::DebugOutputTable()
|
||
|
|
{
|
||
|
|
Displayf("=============================================");
|
||
|
|
Displayf("======= CDataFileMount interface table ======");
|
||
|
|
Displayf("=============================================");
|
||
|
|
#if PARSER_ALL_METADATA_HAS_NAMES
|
||
|
|
for(int i=0; i < sm_Interfaces.GetMaxCount(); ++i)
|
||
|
|
{
|
||
|
|
Displayf("[%s]: %s", parser_DataFileType_Strings[i], sm_Interfaces[i]? "valid":"NULL");
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
Displayf("CAN'T DISPLAY LIST IF !PARSER_ALL_METADATA_HAS_NAMES");
|
||
|
|
#endif
|
||
|
|
Displayf("=============================================");
|
||
|
|
}
|
||
|
|
#endif
|