static LPBYTE LoadFileToMemory(TCascStorage * hs, const char * szFileName, DWORD * pcbFileData)
{
LPBYTE pbEncodingKey = NULL;
LPBYTE pbFileData = NULL;
// Try to find encoding key for the file
pbEncodingKey = RootHandler_GetKey(hs->pRootHandler, szFileName);
if(pbEncodingKey != NULL)
pbFileData = LoadFileToMemory(hs, pbEncodingKey, pcbFileData);
return pbFileData;
}
/*!***********************************************************************
@Function LoadModelFromFile
@Access public
@Param const char * c_pszModel
@Returns bool
@Description
*************************************************************************/
bool ResourceManager::LoadModelFromFile(const char* c_pszModel)
{
char* pData;
Uint32 uiFileSize;
if(!LoadFileToMemory(c_pszModel, &pData, uiFileSize))
{
return false;
}
bool bRes = LoadModelFromMemory(c_pszModel, pData, uiFileSize);
delete [] pData;
return bRes;
}
static DWORD ScanDirectoryFile(
TCascStorage * hs,
LPBYTE pbRootFile,
LPBYTE pbFileEnd)
{
PDIABLO3_NAMED_ENTRY pNamedEntry;
DIABLO3_DIR_HEADER RootHeader;
DIABLO3_DIR_HEADER DirHeader;
LPBYTE pbSubDir;
DWORD dwTotalFileCount;
DWORD cbNamedEntry;
DWORD cbSubDir;
int nError;
// Parse the directory header in order to retrieve the items
nError = ParseDirectoryHeader(&RootHeader, pbRootFile, pbFileEnd);
if(nError != ERROR_SUCCESS)
return 0;
// Add the root directory's entries
dwTotalFileCount = RootHeader.dwEntries1 + RootHeader.dwEntries2 + RootHeader.dwEntries3;
// Parse the named entries
for(DWORD i = 0; i < RootHeader.dwEntries3; i++)
{
// Get the this named entry
if((cbNamedEntry = VerifyNamedFileEntry(RootHeader.pbEntries3, pbFileEnd)) == 0)
return 0;
pNamedEntry = (PDIABLO3_NAMED_ENTRY)RootHeader.pbEntries3;
RootHeader.pbEntries3 += cbNamedEntry;
// Load the subdirectory to memory
pbSubDir = LoadFileToMemory(hs, pNamedEntry->EncodingKey.Value, &cbSubDir);
if(pbSubDir != NULL)
{
// Count the files in the subdirectory
if(ParseDirectoryHeader(&DirHeader, pbSubDir, pbSubDir + cbSubDir) == ERROR_SUCCESS)
{
dwTotalFileCount += DirHeader.dwEntries1 + DirHeader.dwEntries2 + DirHeader.dwEntries3;
}
// Free the subdirectory
CASC_FREE(pbSubDir);
}
}
// Return the total number of entries
return dwTotalFileCount;
}
adError LoadBitmap(const TString& fileName, adBitmapPtr pBitmap)
{
if(pBitmap == NULL)
return AD_ERROR_INVALID_POINTER;
if(pBitmap->width == 0 || pBitmap->height == 0 || pBitmap->stride == 0 ||
pBitmap->format <= AD_PIXEL_FORMAT_NONE || pBitmap->format >= AD_PIXEL_FORMAT_SIZE ||
pBitmap->data == NULL)
return AD_ERROR_INVALID_BITMAP;
if(!IsFileExists(fileName.c_str()))
return AD_ERROR_FILE_IS_NOT_EXIST;
adError result = AD_ERROR_UNKNOWN;
HGLOBAL hGlobal = LoadFileToMemory(fileName.c_str());
if(hGlobal)
{
TImage *pImage = TImage::Load(hGlobal);
if(pImage)
{
TView::Format format = TView::None;
switch(pBitmap->format)
{
case AD_PIXEL_FORMAT_ARGB32:
format = TView::Bgra32;
break;
}
if(format)
{
TView view(pBitmap->width, pBitmap->height, pBitmap->stride, format, pBitmap->data);
Simd::ResizeBilinear(*pImage->View(), view);
result = AD_OK;
}
delete pImage;
}
else
result = AD_ERROR_CANT_LOAD_IMAGE;
::GlobalFree(hGlobal);
}
else
result = AD_ERROR_CANT_OPEN_FILE;
return result;
}
int RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
{
TRootHandler_Diablo3 * pRootHandler;
PCASC_MAP pPackageMap = NULL;
LPBYTE pbRootFileEnd = pbRootFile + cbRootFile;
LPBYTE pbPackagesDat = NULL;
DWORD dwTotalFileCount;
DWORD cbPackagesDat = 0;
int nError;
// Allocate the root handler object
hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_Diablo3, 1);
if(pRootHandler == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Fill-in the handler functions
memset(pRootHandler, 0, sizeof(TRootHandler_Diablo3));
pRootHandler->Insert = (ROOT_INSERT)D3Handler_Insert;
pRootHandler->Search = (ROOT_SEARCH)D3Handler_Search;
pRootHandler->EndSearch = (ROOT_ENDSEARCH)D3Handler_EndSearch;
pRootHandler->GetKey = (ROOT_GETKEY)D3Handler_GetKey;
pRootHandler->Close = (ROOT_CLOSE)D3Handler_Close;
pRootHandler->GetFileId = (ROOT_GETFILEID)D3Handler_GetFileId;
// Fill-in the flags
pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES;
// Scan the total number of files in the root directories
// Reserve space for extra files
dwTotalFileCount = ScanDirectoryFile(hs, pbRootFile, pbRootFileEnd);
if(dwTotalFileCount == 0)
return ERROR_FILE_CORRUPT;
dwTotalFileCount += CASC_EXTRA_FILES;
// Allocate the global linear file table
// Note: This is about 18 MB of memory for Diablo III PTR build 30013
nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, dwTotalFileCount);
if(nError != ERROR_SUCCESS)
return nError;
// Allocate global buffer for file names.
// The size of the buffer was taken from Diablo III build 30013
nError = Array_Create(&pRootHandler->FileNames, char, 0x01000000);
if(nError != ERROR_SUCCESS)
return nError;
// Create map of ROOT_ENTRY -> FileEntry
pRootHandler->pRootMap = Map_Create(dwTotalFileCount, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash));
if(pRootHandler->pRootMap == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Parse the ROOT file and insert all entries in the file table
nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFileEnd, DIABLO3_INVALID_INDEX);
if(nError == ERROR_SUCCESS)
{
size_t dwRootEntries = pRootHandler->FileTable.ItemCount;
// We expect the number of level-0 to be less than maximum
assert(dwRootEntries < DIABLO3_MAX_SUBDIRS);
// Now parse the all root items and load them
for(DWORD i = 0; i < dwRootEntries; i++)
{
PCASC_FILE_ENTRY pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, i);
// Load the entire file to memory
pbRootFile = LoadFileToMemory(hs, pRootEntry->EncodingKey.Value, &cbRootFile);
if(pbRootFile != NULL)
{
nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFile + cbRootFile, i);
CASC_FREE(pbRootFile);
}
}
}
// Note: The file "Base\Data_D3\PC\Misc\Packages.dat" contains the names
// of the files (without level-0 and level-1 directory). We can use these
// names for supplying the missing extensions
if(nError == ERROR_SUCCESS)
{
// Load the entire file to memory
pbPackagesDat = LoadFileToMemory(hs, "Base\\Data_D3\\PC\\Misc\\Packages.dat", &cbPackagesDat);
if(pbPackagesDat != NULL)
{
pPackageMap = CreatePackageMap(pbPackagesDat, pbPackagesDat + cbPackagesDat);
}
}
// Vast majorify of files at this moment don't have names.
// We can load the Base\CoreTOC.dat file in order
// to get directory asset indexes, file names and extensions
if(nError == ERROR_SUCCESS)
{
LPBYTE pbCoreTOC;
DWORD cbCoreTOC = 0;
// Load the entire file to memory
pbCoreTOC = LoadFileToMemory(hs, "Base\\CoreTOC.dat", &cbCoreTOC);
if(pbCoreTOC != NULL)
{
ParseCoreTOC(pRootHandler, pPackageMap, pbCoreTOC, pbCoreTOC + cbCoreTOC);
CASC_FREE(pbCoreTOC);
}
}
// Free the packages map
if(pPackageMap != NULL)
Map_Free(pPackageMap);
if(pbPackagesDat != NULL)
CASC_FREE(pbPackagesDat);
return nError;
}
