966 lines
24 KiB
C++
966 lines
24 KiB
C++
#pragma warning(disable: 4505)
|
||
#include <direct.h>
|
||
#include <sys/stat.h>
|
||
#include <io.h>
|
||
#include <boost/shared_ptr.hpp>
|
||
#include <boost/algorithm/string.hpp>
|
||
#include <fstream>
|
||
|
||
#pragma warning(push, 3)
|
||
#include <cryptopp/osrng.h>
|
||
#pragma warning(pop)
|
||
|
||
#include <lzo/lzoLibLink.h>
|
||
#pragma comment(lib, "winmm.lib")
|
||
|
||
#include <EterBase/Utils.h>
|
||
#include <EterBase/Filename.h>
|
||
#include <EterLib/TextFileLoader.h>
|
||
#include <EterPack/EterPackManager.h>
|
||
|
||
using std::string;
|
||
using std::vector;
|
||
using boost::unordered_map;
|
||
using std::size_t;
|
||
|
||
typedef unordered_map<string, bool, stringhash> NameDict;
|
||
|
||
string g_st_packName;
|
||
|
||
NameDict g_map_ignoreFileName;
|
||
NameDict g_map_ignoreDirName;
|
||
NameDict g_map_ignoreBasePath;
|
||
|
||
typedef unordered_map<string, BYTE, stringhash> TStrMap;
|
||
|
||
TStrMap g_PackTypeByExtNameMap;
|
||
std::string g_strFolderName = "pack/";
|
||
|
||
static BYTE s_IV[32];
|
||
|
||
typedef unordered_map<string, string, stringhash> MapNameToSDBFile;
|
||
|
||
MapNameToSDBFile g_map_SDBFileList;
|
||
|
||
bool IsSDBSupportRequired( const std::string& strFile, std::string& strMapName)
|
||
{
|
||
MapNameToSDBFile::const_iterator cit = g_map_SDBFileList.find(strFile);
|
||
|
||
if (cit != g_map_SDBFileList.end())
|
||
{
|
||
strMapName = cit->second;
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool LoadList(const char* fileName, vector<string>* pvec_stLine)
|
||
{
|
||
FILE* fp;
|
||
|
||
if (0 != fopen_s(&fp, fileName, "r"))
|
||
return false;
|
||
|
||
char line[256];
|
||
while (fgets(line, sizeof(line)-1, fp))
|
||
{
|
||
size_t lineLen = strlen(line);
|
||
|
||
if (line[lineLen-1] == '\n')
|
||
line[lineLen-1] = '\0';
|
||
|
||
if (line[lineLen-2] == '\r')
|
||
line[lineLen-2] = '\0';
|
||
|
||
pvec_stLine->push_back(line);
|
||
}
|
||
fclose(fp);
|
||
return true;
|
||
}
|
||
|
||
void IgnoreFileList_Append(const string& c_st_fileName)
|
||
{
|
||
printf("ignore_file: [%s]\n", c_st_fileName.c_str());
|
||
|
||
if (c_st_fileName.find('*') >= 0) // strchr(c_st_fileName.c_str(), '*')
|
||
{
|
||
WIN32_FIND_DATA findData;
|
||
HANDLE hFind;
|
||
hFind = FindFirstFile(c_st_fileName.c_str(), &findData);
|
||
if (hFind != INVALID_HANDLE_VALUE)
|
||
{
|
||
std::string st_childName;
|
||
|
||
do
|
||
{
|
||
st_childName = findData.cFileName;
|
||
StringPath(st_childName);
|
||
|
||
g_map_ignoreFileName.insert(NameDict::value_type(st_childName, true));
|
||
}
|
||
while (FindNextFile(hFind, &findData));
|
||
}
|
||
FindClose(hFind);
|
||
}
|
||
else
|
||
{
|
||
string st_fileName = c_st_fileName;
|
||
StringPath(st_fileName);
|
||
g_map_ignoreFileName.insert(NameDict::value_type(st_fileName, true));
|
||
}
|
||
}
|
||
|
||
bool IgnoreFileList_Load(const char* fileName)
|
||
{
|
||
vector<string> nameList;
|
||
if (!LoadList(fileName, &nameList))
|
||
return false;
|
||
|
||
for_each(nameList.begin(), nameList.end(), IgnoreFileList_Append);
|
||
return true;
|
||
}
|
||
|
||
void IgnoreDirList_Append(const string& c_st_dirName)
|
||
{
|
||
std::string st_dirName = c_st_dirName;
|
||
StringPath(st_dirName);
|
||
|
||
g_map_ignoreDirName.insert(NameDict::value_type(st_dirName, true));
|
||
}
|
||
|
||
bool IgnoreDirList_Load(const char* fileName)
|
||
{
|
||
vector<string> nameList;
|
||
if (!LoadList(fileName, &nameList))
|
||
return false;
|
||
|
||
for_each(nameList.begin(), nameList.end(), IgnoreDirList_Append);
|
||
return true;
|
||
}
|
||
|
||
void IgnoreBasePathList_Append(const string& c_st_basePath)
|
||
{
|
||
std::string st_basePath = c_st_basePath;
|
||
StringPath(st_basePath);
|
||
|
||
g_map_ignoreBasePath.insert(NameDict::value_type(st_basePath, true));
|
||
}
|
||
|
||
bool IgnoreBasePathList_Load(const char* fileName)
|
||
{
|
||
vector<string> nameList;
|
||
if (!LoadList(fileName, &nameList))
|
||
return false;
|
||
|
||
for_each(nameList.begin(), nameList.end(), IgnoreBasePathList_Append);
|
||
return true;
|
||
}
|
||
|
||
void RegisterPackTypeByExtName(const char * c_pszExt, BYTE packType, bool isOverwrite=false)
|
||
{
|
||
if (isOverwrite)
|
||
g_PackTypeByExtNameMap[c_pszExt] = packType;
|
||
else
|
||
g_PackTypeByExtNameMap.insert(TStrMap::value_type(c_pszExt, packType));
|
||
}
|
||
|
||
void RecursivePack(CEterPack & pack, const char * filename, std::vector<std::string>& vecCompressedTextures, std::vector<int>& vecCompressedTexMipMaps)
|
||
{
|
||
WIN32_FIND_DATA fdata;
|
||
HANDLE hFind;
|
||
char temp[512];
|
||
|
||
if ((hFind = FindFirstFile(filename, &fdata)) != INVALID_HANDLE_VALUE)
|
||
{
|
||
do
|
||
{
|
||
if (fdata.cFileName[0] == '.')
|
||
continue;
|
||
|
||
if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
||
{
|
||
strcpy_s(temp, fdata.cFileName);
|
||
StringPath(temp);
|
||
|
||
if (g_map_ignoreDirName.end() != g_map_ignoreDirName.find(temp))
|
||
{
|
||
//printf("Exclude1 %s\n", fdata.cFileName);
|
||
continue;
|
||
}
|
||
|
||
strcpy_s(temp, filename);
|
||
char *p = strchr(temp, '*'); // <20>ڿ<EFBFBD> * <20><> <20><><EFBFBD>ش<EFBFBD>.
|
||
if (p) *p = '\0';
|
||
|
||
StringPath(temp);
|
||
|
||
if (g_map_ignoreBasePath.end() != g_map_ignoreBasePath.find(temp))
|
||
{
|
||
//printf("Exclude2 %s\n", fdata.cFileName);
|
||
continue;
|
||
}
|
||
|
||
sprintf_s(p, sizeof(temp) - (p - temp), "%s/*", fdata.cFileName);
|
||
|
||
RecursivePack(pack, temp, vecCompressedTextures, vecCompressedTexMipMaps);
|
||
continue;
|
||
}
|
||
|
||
strcpy_s(temp, fdata.cFileName);
|
||
StringPath(temp);
|
||
|
||
if (g_map_ignoreFileName.end() != g_map_ignoreFileName.find(temp))
|
||
{
|
||
//printf("Exclude3 %s\n", fdata.cFileName);
|
||
continue;
|
||
}
|
||
|
||
strcpy_s(temp, filename);
|
||
char *p = NULL;
|
||
|
||
if ((p = strrchr(temp, '*'))!=NULL) // <20>ڿ<EFBFBD> * <20><> <20><><EFBFBD>ش<EFBFBD>.
|
||
*p = '\0';
|
||
|
||
StringPath(temp);
|
||
|
||
if (g_map_ignoreBasePath.end() != g_map_ignoreBasePath.find(temp))
|
||
{
|
||
//printf("Exclude4 %s\n", fdata.cFileName);
|
||
continue;
|
||
}
|
||
|
||
if (p)
|
||
sprintf_s(p, sizeof(temp) - (p - temp), "%s", fdata.cFileName);
|
||
else
|
||
sprintf_s(temp, sizeof(temp), "%s", fdata.cFileName);
|
||
|
||
std::string ext(temp);
|
||
stl_lowers(ext);
|
||
|
||
//FIXME : TEMP HARD CODE
|
||
if (!CFileNameHelper::GetExtension(ext).compare("wdp"))
|
||
continue;
|
||
|
||
BYTE packType = COMPRESSED_TYPE_NONE;
|
||
{
|
||
bool bSuccessCompTexture = false;
|
||
|
||
if (!bSuccessCompTexture)
|
||
{
|
||
unordered_map<std::string, BYTE, stringhash>::iterator it = g_PackTypeByExtNameMap.find(ext);
|
||
|
||
if (g_PackTypeByExtNameMap.end() != it)
|
||
packType = it->second;
|
||
}
|
||
|
||
std::string strRelatedMapName;
|
||
|
||
if (packType == COMPRESSED_TYPE_HYBRIDCRYPT && IsSDBSupportRequired(temp, strRelatedMapName))
|
||
packType = COMPRESSED_TYPE_HYBRIDCRYPT_WITHSDB;
|
||
|
||
if (pack.Put(temp, NULL, packType, strRelatedMapName))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("pack: %s\n", temp);
|
||
}
|
||
else
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("pack failed: %s\n", temp);
|
||
CMakePackLog::GetSingleton().WriteErrorf("pack failed: %s\n", temp);
|
||
}
|
||
|
||
}
|
||
}
|
||
while (FindNextFile(hFind, &fdata));
|
||
}
|
||
}
|
||
|
||
void AddIndex(const char * c_szName, const char * c_szDirectory)
|
||
{
|
||
std::string strIndexFileName = g_strFolderName + "Index.new";
|
||
|
||
FILE * fp;
|
||
|
||
if (0 != fopen_s(&fp, strIndexFileName.c_str(), "a+"))
|
||
{
|
||
printf("%s append open error", strIndexFileName.c_str());
|
||
abort();
|
||
}
|
||
|
||
char szTmp[MAX_PATH + 1];
|
||
strcpy_s(szTmp, c_szDirectory);
|
||
|
||
char * p = strrchr(szTmp, '/');
|
||
*(++p) = '\0';
|
||
|
||
fprintf(fp, "%s\n%s\n", szTmp, c_szName);
|
||
fclose(fp);
|
||
}
|
||
|
||
void MakeReducioHeader( std::vector<std::string>& textures, std::vector<int>& mipMapCounts)
|
||
{
|
||
string st_HeaderFilePath;
|
||
st_HeaderFilePath = g_strFolderName;
|
||
st_HeaderFilePath += g_st_packName;
|
||
st_HeaderFilePath += ".rdch";
|
||
|
||
std::ofstream outFile( st_HeaderFilePath.c_str(), std::ios_base::binary | std::ios_base::out);
|
||
|
||
int nItemCount = textures.size();
|
||
|
||
outFile.write((const char*)&nItemCount, sizeof(int));
|
||
|
||
for( int i = 0; i < nItemCount; ++i)
|
||
{
|
||
int iNameLength = textures[i].length();
|
||
outFile.write((const char*)&iNameLength, sizeof(int));
|
||
outFile.write((const char*)&mipMapCounts[i], sizeof(int));
|
||
outFile.write(textures[i].c_str(), iNameLength);
|
||
}
|
||
|
||
outFile.close();
|
||
}
|
||
|
||
|
||
bool MakePackFiles(const std::vector<std::string>& filePaths, CEterPackManager* pPackManager)
|
||
{
|
||
string st_packName = g_st_packName.empty() ? "noname" : g_st_packName;
|
||
|
||
string st_packFilePath;
|
||
st_packFilePath = g_strFolderName;
|
||
st_packFilePath += st_packName;
|
||
|
||
CMakePackLog::GetSingleton().Writef("\n + Making %s\n", st_packName.c_str());
|
||
|
||
CEterFileDict fileDict;
|
||
CEterPack* pPack = new CEterPack;
|
||
|
||
if (!pPack->Create(fileDict, st_packFilePath.c_str(), g_strFolderName.c_str(), false, s_IV))
|
||
return false;
|
||
|
||
std::vector<std::string>::const_iterator i = filePaths.begin();
|
||
std::vector<std::string>::const_iterator e = filePaths.end();
|
||
|
||
bool bAddToIndex = false;
|
||
|
||
std::vector<std::string> vecCompressedTextures;
|
||
std::vector<int> vecCompressedTexMipMaps;
|
||
|
||
bool bSuccess = true;
|
||
while (i != e)
|
||
{
|
||
const std::string& path = *i;
|
||
std::string strRelatedMap;
|
||
|
||
char temp[1024];
|
||
strcpy_s(temp, path.c_str());
|
||
|
||
StringPath(temp);
|
||
|
||
std::string lowerFilePath(temp);
|
||
stl_lowers(lowerFilePath);
|
||
|
||
BYTE packType = COMPRESSED_TYPE_NONE;
|
||
|
||
std::string ext = CFileNameHelper::GetExtension(lowerFilePath);
|
||
|
||
bool bSuccessCompTexture = false;
|
||
|
||
if (!ext.compare("wdp"))
|
||
{
|
||
i++;
|
||
continue;
|
||
}
|
||
|
||
if (!bSuccessCompTexture)
|
||
{
|
||
unordered_map<std::string, BYTE, stringhash>::iterator it = g_PackTypeByExtNameMap.find(ext);
|
||
|
||
if (g_PackTypeByExtNameMap.end() != it)
|
||
packType = it->second;
|
||
}
|
||
|
||
if (packType == COMPRESSED_TYPE_HYBRIDCRYPT)
|
||
{
|
||
bAddToIndex = true;
|
||
if (IsSDBSupportRequired(temp, strRelatedMap))
|
||
{
|
||
packType = COMPRESSED_TYPE_HYBRIDCRYPT_WITHSDB;
|
||
}
|
||
}
|
||
|
||
if (pPack->Put(temp, NULL, packType, strRelatedMap))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("pack: %s\n", temp);
|
||
}
|
||
else
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("pack failed: %s\n", temp);
|
||
CMakePackLog::GetSingleton().WriteErrorf("pack failed: %s\n", temp);
|
||
bSuccess = false;
|
||
}
|
||
i++;
|
||
}
|
||
|
||
pPackManager->RegisterPackWhenPackMaking(st_packFilePath.c_str(), g_strFolderName.c_str(), pPack);
|
||
|
||
if (bAddToIndex)
|
||
{
|
||
AddIndex(st_packName.c_str(), g_strFolderName.c_str());
|
||
}
|
||
|
||
pPack->DeleteUnreferencedData();
|
||
pPack->EncryptIndexFile();
|
||
|
||
//write it
|
||
if (vecCompressedTextures.size() > 0)
|
||
{
|
||
MakeReducioHeader( vecCompressedTextures, vecCompressedTexMipMaps);
|
||
}
|
||
|
||
return bSuccess;
|
||
}
|
||
|
||
void MakePack(const char * c_szPackName, const char * c_szDirectory, CEterPackManager* pPackManager)
|
||
{
|
||
string st_packName = g_st_packName.empty() ? c_szPackName : g_st_packName;
|
||
string st_packFilePath;
|
||
st_packFilePath = g_strFolderName;
|
||
st_packFilePath += st_packName;
|
||
|
||
CMakePackLog::GetSingleton().Writef("\n + Making %s\n", st_packName.c_str());
|
||
|
||
//CEterPack pack;
|
||
CEterFileDict fileDict;
|
||
CEterPack* pPack = new CEterPack;
|
||
|
||
if (!pPack->Create(fileDict, st_packFilePath.c_str(), g_strFolderName.c_str(), false, s_IV))
|
||
return;
|
||
|
||
std::string stFolder(c_szDirectory);
|
||
stl_lowers(stFolder);
|
||
|
||
std::vector<std::string> vecCompressedTextures;
|
||
std::vector<int> vecCompressedTexMipMaps;
|
||
|
||
RecursivePack(*pPack, stFolder.c_str(), vecCompressedTextures, vecCompressedTexMipMaps);
|
||
AddIndex(st_packName.c_str(), stFolder.c_str());
|
||
|
||
pPack->DeleteUnreferencedData();
|
||
pPack->EncryptIndexFile();
|
||
|
||
//write it
|
||
if (vecCompressedTextures.size() > 0)
|
||
{
|
||
MakeReducioHeader( vecCompressedTextures, vecCompressedTexMipMaps);
|
||
}
|
||
|
||
pPackManager->RegisterPackWhenPackMaking(st_packFilePath.c_str(), g_strFolderName.c_str(), pPack);
|
||
}
|
||
|
||
bool MakeRecursivePack(const char * c_szPackName, CTextFileLoader & rTextFileLoader, CEterPackManager* pPackManager)
|
||
{
|
||
string st_packName = g_st_packName.empty() ? c_szPackName : g_st_packName;
|
||
string st_packFilePath;
|
||
st_packFilePath = g_strFolderName;
|
||
st_packFilePath += st_packName;
|
||
|
||
string st_testName = g_strFolderName + c_szPackName;
|
||
assert(st_testName == st_packFilePath);
|
||
|
||
//CEterPack pack;
|
||
CEterFileDict fileDict;
|
||
CEterPack* pPack = new CEterPack;
|
||
|
||
std::vector<std::string> vecCompressedTextures;
|
||
std::vector<int> vecCompressedTexMipMaps;
|
||
|
||
if (!pPack->Create(fileDict, st_packFilePath.c_str(), g_strFolderName.c_str(), false, s_IV))
|
||
return false;
|
||
|
||
for (DWORD i = 0; i < rTextFileLoader.GetChildNodeCount(); ++i)
|
||
{
|
||
if (rTextFileLoader.SetChildNode(i))
|
||
{
|
||
bool bAddIndex = false;
|
||
std::string strAddIndex;
|
||
if (rTextFileLoader.GetTokenString("addindex", &strAddIndex))
|
||
if (0 == strAddIndex.compare("TRUE"))
|
||
bAddIndex = true;
|
||
|
||
std::string strFileName;
|
||
if (!rTextFileLoader.GetTokenString("filename", &strFileName))
|
||
continue;
|
||
|
||
RecursivePack(*pPack, strFileName.c_str(), vecCompressedTextures, vecCompressedTexMipMaps);
|
||
|
||
if (bAddIndex)
|
||
{
|
||
AddIndex(c_szPackName, strFileName.c_str());
|
||
}
|
||
|
||
rTextFileLoader.SetParentNode();
|
||
}
|
||
}
|
||
|
||
pPack->DeleteUnreferencedData();
|
||
pPack->EncryptIndexFile();
|
||
|
||
//write it
|
||
if (vecCompressedTextures.size() > 0)
|
||
{
|
||
MakeReducioHeader( vecCompressedTextures, vecCompressedTexMipMaps);
|
||
}
|
||
|
||
pPackManager->RegisterPackWhenPackMaking(st_packFilePath.c_str(), g_strFolderName.c_str(), pPack);
|
||
return true;
|
||
}
|
||
|
||
int main(int argc, char **argv)
|
||
{
|
||
if (argc < 2)
|
||
{
|
||
puts("USAGE:");
|
||
printf("%s --createiv <filename>\n", argv[0]);
|
||
printf("%s --openiv <filename>\n", argv[0]);
|
||
printf("%s --extract <packname> [<IV filename>]\n", argv[0]);
|
||
printf("%s <scriptname>\n", argv[0]);
|
||
return 0;
|
||
}
|
||
|
||
boost::shared_ptr<CLZO> lzo(new CLZO);
|
||
boost::shared_ptr<CEterPackManager> packMgr(new CEterPackManager);
|
||
|
||
if (!strcmp(argv[1], "--createiv"))
|
||
{
|
||
// .exe --createiv <filename>
|
||
if (argc != 3)
|
||
{
|
||
printf("Usage: %s --createiv <filename>\n", argv[0]);
|
||
return 1;
|
||
}
|
||
|
||
CFileBase diskFile;
|
||
|
||
if (diskFile.Create(argv[2], CFileBase::FILEMODE_WRITE))
|
||
{
|
||
BYTE iv[32];
|
||
|
||
CryptoPP::AutoSeededRandomPool prng;
|
||
prng.GenerateBlock(iv, sizeof(iv));
|
||
|
||
diskFile.Write(iv, sizeof(iv));
|
||
diskFile.Close();
|
||
|
||
char szHex[32*2+1];
|
||
|
||
for (int i = 0; i < 32; ++i)
|
||
sprintf_s(szHex + i * 2, sizeof(szHex) - i * 2, "%02x", iv[i]);
|
||
|
||
printf("IV %s created (hex %s)\n", argv[2], szHex);
|
||
_chmod(argv[2], _S_IREAD); // <20>б<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
return 0;
|
||
}
|
||
|
||
printf("Cannot open %s, File may already exist\n", argv[2]);
|
||
return 1;
|
||
}
|
||
else if (!strcmp(argv[1], "--openiv"))
|
||
{
|
||
// .exe --openiv <filename>
|
||
if (argc != 3)
|
||
{
|
||
printf("Usage: %s --openiv <filename>\n", argv[0]);
|
||
return 1;
|
||
}
|
||
|
||
CMappedFile file;
|
||
const BYTE* iv;
|
||
|
||
if (file.Create(argv[2], (const void**) &iv, 0, 32))
|
||
{
|
||
char szHex[32*2+1];
|
||
|
||
for (int i = 0; i < 32; ++i)
|
||
sprintf_s(szHex + i * 2, sizeof(szHex) - i * 2, "%02x", iv[i]);
|
||
|
||
printf("IV %s loaded (hex %s)", argv[2], szHex);
|
||
return 0;
|
||
}
|
||
|
||
printf("File not found or invalid format: %s\n", argv[2]);
|
||
return 1;
|
||
}
|
||
else if (!strcmp(argv[1], "--extract"))
|
||
{
|
||
// .exe --extract <packname> [<IV filename>]
|
||
if (argc < 3)
|
||
{
|
||
printf("Usage: %s --extract <packname> [<IV filename>]\n", argv[0]);
|
||
return 1;
|
||
}
|
||
|
||
CMappedFile file;
|
||
const BYTE* iv = NULL;
|
||
|
||
if (argc >= 4)
|
||
{
|
||
if (!file.Create(argv[3], (const void**) &iv, 0, 32))
|
||
{
|
||
printf("Cannot load IV file %s\n", argv[3]);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
|
||
CEterPack pack;
|
||
CEterFileDict dict;
|
||
|
||
if (pack.Create(dict, argv[2], "", true, iv))
|
||
{
|
||
|
||
pack.Extract();
|
||
return 0;
|
||
}
|
||
|
||
printf("Cannot extract pack %s\n", argv[2]);
|
||
return 1;
|
||
}
|
||
|
||
HANDLE hThread = GetCurrentThread();
|
||
SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST);
|
||
SetLogLevel(1);
|
||
|
||
if (2 != argc)
|
||
{
|
||
printf("Usage: %s [ScriptFileName]\n", argv[0]);
|
||
return 1;
|
||
}
|
||
|
||
char* pcExt = strrchr(argv[1], '.');
|
||
|
||
if (pcExt)
|
||
{
|
||
std::string stLogFileName(argv[1], pcExt);
|
||
CMakePackLog::GetSingleton().SetFileName(stLogFileName.c_str());
|
||
}
|
||
|
||
CTextFileLoader TextFileLoader;
|
||
|
||
if (!TextFileLoader.Load(argv[1]))
|
||
{
|
||
printf("Failed to load pack script\n");
|
||
return 1;
|
||
}
|
||
|
||
if (TextFileLoader.GetTokenString("foldername", &g_strFolderName))
|
||
{
|
||
_mkdir(g_strFolderName.c_str());
|
||
g_strFolderName += "/";
|
||
}
|
||
|
||
if (TextFileLoader.GetTokenString("packname", &g_st_packName))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\nPackName: %s\n", g_st_packName.c_str());
|
||
}
|
||
|
||
// TextFileLoader.GetTokenInteger("compresstexture", &iCompressTexQuality);
|
||
////////////////////////////////////////////////////////////
|
||
IgnoreDirList_Load("ignore_dir_list.txt");
|
||
IgnoreFileList_Load("ignore_file_list.txt");
|
||
IgnoreBasePathList_Load("ignore_basepath_list.txt");
|
||
|
||
std::string strIndexFileName = g_strFolderName + "Index.new";
|
||
FILE * fp;
|
||
|
||
if (0 != fopen_s(&fp, strIndexFileName.c_str(), "w"))
|
||
{
|
||
char szCurDir[MAX_PATH + 1];
|
||
GetCurrentDirectory(MAX_PATH, szCurDir);
|
||
|
||
printf("%s cannot be opened. File is not a file, nonexistent or in use.\n"
|
||
"Current directory: %s\n", strIndexFileName.c_str(), szCurDir);
|
||
return 1;
|
||
}
|
||
|
||
fprintf(fp, "PACK\n"); // Search Mode, 1 == <20>ѿ<EFBFBD><D1BF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
fclose(fp);
|
||
|
||
////////////////////////////////////////////////////////////
|
||
|
||
CTokenVector * pTokenVector;
|
||
|
||
// ExcludedFolderNameList - <20>ش<EFBFBD> <20><><EFBFBD><EFBFBD> <20≯<EFBFBD><CCB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
|
||
if (TextFileLoader.GetTokenVector("excludedfoldernamelist", &pTokenVector))
|
||
{
|
||
//printf("\n - ExcludedFolderNameList\n");
|
||
CMakePackLog::GetSingleton().Writef("\n - ExcludedFolderNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
//printf(" %s\n", rstrName.c_str());
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
// @fixme302 "CVS" -> rstrName.c_str()
|
||
IgnoreDirList_Append(rstrName.c_str());
|
||
}
|
||
}
|
||
|
||
// ExcludedPathList - <20>н<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
|
||
if (TextFileLoader.GetTokenVector("excludedpathlist", &pTokenVector))
|
||
{
|
||
//printf("\n - ExcludedPathList\n");
|
||
CMakePackLog::GetSingleton().Write("\n - ExcludedPathList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
//printf(" %s\n", rstrName.c_str());
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
// @fixme301 "d:/ymir work/sound/" -> rstrName.c_str()
|
||
IgnoreBasePathList_Append(rstrName.c_str());
|
||
}
|
||
}
|
||
|
||
// ExcludedFileNameList - <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD≯<EFBFBD><CCB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
|
||
if (TextFileLoader.GetTokenVector("excludedfilenamelist", &pTokenVector))
|
||
{
|
||
//printf("\n - ExcludedFileNameList\n");
|
||
CMakePackLog::GetSingleton().Writef("\n - ExcludedFileNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
//printf(" %s\n", rstrName.c_str());
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
IgnoreFileList_Append(rstrName.c_str());
|
||
}
|
||
}
|
||
|
||
// CompressExtNameList - <20>ش<EFBFBD> Ȯ<><C8AE><EFBFBD>ڸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> compress <20>Ѵ<EFBFBD>.
|
||
if (TextFileLoader.GetTokenVector("compressextnamelist", &pTokenVector))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n - CompressExtNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
RegisterPackTypeByExtName(rstrName.c_str(), COMPRESSED_TYPE_COMPRESS);
|
||
}
|
||
}
|
||
|
||
// SecurityExtNameList - <20>ش<EFBFBD> Ȯ<><C8AE><EFBFBD>ڸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> encrypt <20>Ѵ<EFBFBD>.
|
||
if (TextFileLoader.GetTokenVector("securityextnamelist", &pTokenVector))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n - SecurityExtNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
RegisterPackTypeByExtName(rstrName.c_str(), COMPRESSED_TYPE_SECURITY);
|
||
}
|
||
}
|
||
|
||
// OldCompressExtNameList - <20>ش<EFBFBD> Ȯ<><C8AE><EFBFBD>ڸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣȭ <20>Ѵ<EFBFBD>.
|
||
if (TextFileLoader.GetTokenVector("oldcompressextnamelist", &pTokenVector))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n - OldCompressExtNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
// OldCompressExtNameList<73><74> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ƴ϶<C6B4> <20><>ȣȭ<C8A3><C8AD> <20>ؾ<EFBFBD><D8BE>ϹǷ<CFB9>
|
||
// <20>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> COMPRESSED_TYPE_SECURITY<54><59> <20>־<EFBFBD><D6BE><EFBFBD>
|
||
RegisterPackTypeByExtName(rstrName.c_str(), COMPRESSED_TYPE_SECURITY);
|
||
}
|
||
}
|
||
|
||
std::string stIVFileName;
|
||
|
||
if (TextFileLoader.GetTokenString("iv", &stIVFileName))
|
||
{
|
||
CMappedFile mappedFile;
|
||
BYTE * pIV;
|
||
|
||
if (mappedFile.Create(stIVFileName.c_str(), (const void **) &pIV, 0, 32))
|
||
memcpy(s_IV, pIV, 32);
|
||
else
|
||
{
|
||
TraceError("IV open error: %s", stIVFileName.c_str());
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
// PanamaExtNameList - <20><><EFBFBD>ο<EFBFBD> <20><>ȣȭ
|
||
if (TextFileLoader.GetTokenVector("panamaextnamelist", &pTokenVector))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n - PanamaExtNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
RegisterPackTypeByExtName(rstrName.c_str(), COMPRESSED_TYPE_PANAMA, true);
|
||
}
|
||
}
|
||
|
||
if (TextFileLoader.GetTokenVector("cshybridencryptexenamelist", &pTokenVector))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n - C/S Hybrid Encrypt ExtNameList\n");
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
CMakePackLog::GetSingleton().Writef(" %s\n", rstrName.c_str());
|
||
|
||
RegisterPackTypeByExtName(rstrName.c_str(), COMPRESSED_TYPE_HYBRIDCRYPT, true);
|
||
}
|
||
}
|
||
|
||
if (TextFileLoader.SetChildNode("rootpackitemlist"))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n + Making RootPack\n");
|
||
MakeRecursivePack("root", TextFileLoader, packMgr.get());
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
|
||
if (TextFileLoader.SetChildNode("localpathpack"))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n + Making RootPack\n");
|
||
MakeRecursivePack(g_st_packName.c_str(), TextFileLoader, packMgr.get());
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
|
||
if (TextFileLoader.SetChildNode("etcpackitemlist"))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n + Making ETCPack\n");
|
||
MakeRecursivePack("ETC", TextFileLoader, packMgr.get());
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
|
||
if (TextFileLoader.SetChildNode("soundpackitemlist"))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n + Making SoundPack\n");
|
||
MakeRecursivePack("sound", TextFileLoader, packMgr.get());
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
|
||
if (TextFileLoader.SetChildNode("sound2packitemlist"))
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n + Making Sound2Pack\n");
|
||
MakeRecursivePack("sound2", TextFileLoader, packMgr.get());
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
|
||
CMakePackLog::GetSingleton().Writef("\n + PackList \n");
|
||
|
||
if (TextFileLoader.SetChildNode("packlist"))
|
||
{
|
||
for (DWORD i = 0; i < TextFileLoader.GetChildNodeCount(); ++i)
|
||
{
|
||
if (TextFileLoader.SetChildNode(i))
|
||
{
|
||
std::string strNodeName;
|
||
if (!TextFileLoader.GetCurrentNodeName(&strNodeName))
|
||
continue;
|
||
|
||
std::string strPathName;
|
||
if (!TextFileLoader.GetTokenString("pathname", &strPathName))
|
||
continue;
|
||
|
||
MakePack(strNodeName.c_str(), strPathName.c_str(), packMgr.get());
|
||
|
||
TextFileLoader.SetParentNode();
|
||
}
|
||
}
|
||
}
|
||
|
||
// SDB ( Supplementary Data Block Required File List)
|
||
if (TextFileLoader.GetTokenVector("sdbfilelist", &pTokenVector))
|
||
{
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
|
||
std::string rstrNameLower = rstrName;
|
||
stl_lowers(rstrNameLower);
|
||
|
||
std::vector<std::string> strs;
|
||
//mapname:sdbfilename
|
||
boost::split(strs, rstrNameLower, boost::is_any_of("?"));
|
||
|
||
if (strs.size() == 1)
|
||
{
|
||
strs.push_back(strs[0]);
|
||
strs[0] = "none";
|
||
}
|
||
|
||
if (strs.size() != 2)
|
||
{
|
||
CMakePackLog::GetSingleton().Writef("\n SDB File Usage: MapName:SDBFileName \n");
|
||
return -1;
|
||
}
|
||
|
||
StringPath(strs[1]);
|
||
g_map_SDBFileList[strs[1]] = strs[0];
|
||
}
|
||
}
|
||
|
||
// filelist<73><74> <20><><EFBFBD>ǿ<EFBFBD> <20>ԷµǾ<C2B5> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ϱ<EFBFBD>
|
||
if (TextFileLoader.GetTokenVector("filelist", &pTokenVector))
|
||
{
|
||
std::vector<std::string> filePaths;
|
||
|
||
CTokenVector::iterator itor = pTokenVector->begin();
|
||
for (; pTokenVector->end() != itor; ++itor)
|
||
{
|
||
std::string & rstrName = *itor;
|
||
std::vector<std::string>::iterator it = std::find( filePaths.begin(), filePaths.end(), rstrName);
|
||
if (it == filePaths.end())
|
||
{
|
||
filePaths.push_back(rstrName);
|
||
}
|
||
}
|
||
|
||
if(!MakePackFiles(filePaths, packMgr.get()))
|
||
{
|
||
CMakePackLog::GetSingleton().FlushError();
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
//make key file for CS hybrid crypt
|
||
std::string strCryptFileName = g_strFolderName + "/" + "cshybridcrypt_" + g_st_packName + ".dat";
|
||
|
||
packMgr->WriteHybridCryptPackInfo(strCryptFileName.c_str());
|
||
|
||
std::string strOldIndexFileName = g_strFolderName + "Index";
|
||
|
||
DeleteFile(strOldIndexFileName.c_str());
|
||
MoveFile(strIndexFileName.c_str(), strOldIndexFileName.c_str());
|
||
|
||
TextFileLoader.Destroy();
|
||
CTextFileLoader::DestroySystem();
|
||
return 0;
|
||
}
|
||
//martysama0134's 2e58d0b8baeb072acdf3afc4a5d1999f
|