bool ExtractWmo()
{
bool success = false;
//const char* ParsArchiveNames[] = {"patch-2.MPQ", "patch.MPQ", "common.MPQ", "expansion.MPQ"};
SFILE_FIND_DATA data;
HANDLE find = SFileFindFirstFile(WorldMpq, "*.wmo", &data, NULL);
if (find != NULL)
{
do
{
std::string str = data.cFileName;
//printf("Extracting wmo %s\n", str.c_str());
success |= ExtractSingleWmo(str);
}
while (SFileFindNextFile(find, &data));
}
SFileFindClose(find);
if (success)
printf("\nExtract wmo complete (No (fatal) errors)\n");
return success;
}
bool ExtractWmo()
{
bool success = true;
std::ifstream wmoList("wmo_list.txt");
if (!wmoList)
{
printf("\nUnable to open wmo_list.txt! Nothing extracted.\n");
return false;
}
std::set<std::string> wmos;
for (;;)
{
std::string str;
std::getline(wmoList, str);
if (str.empty())
break;
wmos.insert(std::move(str));
}
for (std::string str : wmos)
success &= ExtractSingleWmo(str);
if (success)
printf("\nExtract wmo complete (No (fatal) errors)\n");
return success;
}
void ExtractGameobjectModels()
{
printf("Extracting GameObject models...\n");
DB2CascFileSource source(CascStorage, "DBFilesClient\\GameObjectDisplayInfo.db2");
DB2FileLoader db2;
if (!db2.Load(&source, GameobjectDisplayInfoLoadInfo::Instance()))
{
printf("Fatal error: Invalid GameObjectDisplayInfo.db2 file format!\n");
exit(1);
}
std::string basepath = szWorkDirWmo;
basepath += "/";
std::string modelListPath = basepath + "temp_gameobject_models";
FILE* model_list = fopen(modelListPath.c_str(), "wb");
if (!model_list)
{
printf("Fatal error: Could not open file %s\n", modelListPath.c_str());
return;
}
for (uint32 rec = 0; rec < db2.GetRecordCount(); ++rec)
{
DB2Record record = db2.GetRecord(rec);
uint32 fileId = record.GetUInt32(0, 0);
if (!fileId)
continue;
std::string fileName = Trinity::StringFormat("FILE%08X.xxx", fileId);
bool result = false;
uint32 header;
if (!GetHeaderMagic(fileName, &header))
continue;
if (header == MODEL_WMO)
result = ExtractSingleWmo(fileName);
else if (header == MODEL_MD20 || header == MODEL_MD21)
result = ExtractSingleModel(fileName);
else
ASSERT(false, "%s header: %d - %c%c%c%c", fileName.c_str(), header, (header >> 24) & 0xFF, (header >> 16) & 0xFF, (header >> 8) & 0xFF, header & 0xFF);
if (result)
{
uint32 displayId = record.GetId();
uint32 path_length = fileName.length();
fwrite(&displayId, sizeof(uint32), 1, model_list);
fwrite(&path_length, sizeof(uint32), 1, model_list);
fwrite(fileName.c_str(), sizeof(char), path_length, model_list);
}
}
fclose(model_list);
printf("Done!\n");
}
void ExtractGameobjectModels()
{
printf("Extracting GameObject models...");
DBCFile dbc(LocaleMpq, "DBFilesClient\\GameObjectDisplayInfo.dbc");
if(!dbc.open())
{
printf("Fatal error: Invalid GameObjectDisplayInfo.dbc file format!\n");
exit(1);
}
std::string basepath = szWorkDirWmo;
basepath += "/";
std::string path;
FILE * model_list = fopen((basepath + "temp_gameobject_models").c_str(), "wb");
for (DBCFile::Iterator it = dbc.begin(); it != dbc.end(); ++it)
{
path = it->getString(1);
if (path.length() < 4)
continue;
FixNameCase((char*)path.c_str(), path.size());
char * name = GetPlainName((char*)path.c_str());
FixNameSpaces(name, strlen(name));
char * ch_ext = GetExtension(name);
if (!ch_ext)
continue;
strToLower(ch_ext);
bool result = false;
if (!strcmp(ch_ext, ".wmo"))
result = ExtractSingleWmo(path);
else if (!strcmp(ch_ext, ".mdl")) // TODO: extract .mdl files, if needed
continue;
else //if (!strcmp(ch_ext, ".mdx") || !strcmp(ch_ext, ".m2"))
result = ExtractSingleModel(path);
if (result)
{
uint32 displayId = it->getUInt(0);
uint32 path_length = strlen(name);
fwrite(&displayId, sizeof(uint32), 1, model_list);
fwrite(&path_length, sizeof(uint32), 1, model_list);
fwrite(name, sizeof(char), path_length, model_list);
}
}
fclose(model_list);
printf("Done!\n");
}
bool ExtractWmo()
{
bool success = true;
for (ArchiveSet::const_iterator ar_itr = gOpenArchives.begin(); ar_itr != gOpenArchives.end() && success; ++ar_itr)
{
vector<string> filelist;
(*ar_itr)->GetFileListTo(filelist);
for (vector<string>::iterator fname = filelist.begin(); fname != filelist.end() && success; ++fname)
{
if (fname->find(".wmo") != string::npos)
{ success = ExtractSingleWmo(*fname); }
}
}
if (success)
{ printf("\nExtract wmo complete (No (fatal) errors)\n"); }
return success;
}
bool ExtractWmo()
{
bool success = true;
//const char* ParsArchiveNames[] = {"patch-2.MPQ", "patch.MPQ", "common.MPQ", "expansion.MPQ"};
for (ArchiveSet::const_iterator ar_itr = gOpenArchives.begin(); ar_itr != gOpenArchives.end() && success; ++ar_itr)
{
std::vector<std::string> filelist;
(*ar_itr)->GetFileListTo(filelist);
for (std::vector<std::string>::iterator fname = filelist.begin(); fname != filelist.end() && success; ++fname)
{
if (fname->find(".wmo") != std::string::npos)
success = ExtractSingleWmo(*fname);
}
}
if (success)
printf("\nExtract wmo complete (No (fatal) errors)\n");
return success;
}
void ExtractGameobjectModels()
{
printf("\n");
printf("Extracting GameObject models...\n");
DBCFile dbc("DBFilesClient\\GameObjectDisplayInfo.dbc");
if (!dbc.open())
{
printf("Fatal error: Invalid GameObjectDisplayInfo.dbc file format!\n");
exit(1);
}
std::string basepath = szWorkDirWmo;
basepath += "/";
std::string path;
StringSet failedPaths;
FILE* model_list = fopen((basepath + "temp_gameobject_models").c_str(), "wb");
for (DBCFile::Iterator it = dbc.begin(); it != dbc.end(); ++it)
{
path = it->getString(1);
if (path.length() < 4)
continue;
fixnamen((char*)path.c_str(), path.size());
char* name = GetPlainName((char*)path.c_str());
fixname2(name, strlen(name));
char* ch_ext = GetExtension(name);
if (!ch_ext)
continue;
strToLower(ch_ext);
bool result = false;
if (!strcmp(ch_ext, ".wmo"))
{
result = ExtractSingleWmo(path);
}
else if (!strcmp(ch_ext, ".mdl"))
{
// TODO: extract .mdl files, if needed
continue;
}
else //if (!strcmp(ch_ext, ".mdx") || !strcmp(ch_ext, ".m2"))
{
result = ExtractSingleModel(path, failedPaths);
}
if (result)
{
uint32 displayId = it->getUInt(0);
uint32 path_length = strlen(name);
fwrite(&displayId, sizeof(uint32), 1, model_list);
fwrite(&path_length, sizeof(uint32), 1, model_list);
fwrite(name, sizeof(char), path_length, model_list);
}
}
fclose(model_list);
if (!failedPaths.empty())
{
printf("Warning: Some models could not be extracted, see below\n");
for (StringSet::const_iterator itr = failedPaths.begin(); itr != failedPaths.end(); ++itr)
printf("Could not find file of model %s\n", itr->c_str());
printf("A few of these warnings are expected to happen, so be not alarmed!\n");
}
printf("Done!\n");
}
bool ADTFile::init(uint32 map_num, uint32 originalMapId)
{
if (dirfileCache)
return initFromCache(map_num, originalMapId);
if (_file.isEof())
return false;
uint32 size;
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE* dirfile = fopen(dirname.c_str(), "ab");
if(!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
if (cacheable)
dirfileCache = new std::vector<ADTOutputCache>();
while (!_file.isEof())
{
char fourcc[5];
_file.read(&fourcc,4);
_file.read(&size, 4);
flipcc(fourcc);
fourcc[4] = 0;
size_t nextpos = _file.getPos() + size;
if (!strcmp(fourcc,"MCIN"))
{
}
else if (!strcmp(fourcc,"MTEX"))
{
}
else if (!strcmp(fourcc,"MMDX"))
{
if (size)
{
char* buf = new char[size];
_file.read(buf, size);
char* p = buf;
while (p < buf + size)
{
std::string path(p);
char* s = GetPlainName(p);
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
ModelInstanceNames.emplace_back(s);
ExtractSingleModel(path);
p += strlen(p) + 1;
}
delete[] buf;
}
}
else if (!strcmp(fourcc,"MWMO"))
{
if (size)
{
char* buf = new char[size];
_file.read(buf, size);
char* p = buf;
while (p < buf + size)
{
std::string path(p);
char* s = GetPlainName(p);
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
WmoInstanceNames.emplace_back(s);
ExtractSingleWmo(path);
p += strlen(p) + 1;
}
delete[] buf;
}
}
//======================
else if (!strcmp(fourcc, "MDDF"))
{
if (size)
{
uint32 doodadCount = size / sizeof(ADT::MDDF);
for (uint32 i = 0; i < doodadCount; ++i)
{
ADT::MDDF doodadDef;
_file.read(&doodadDef, sizeof(ADT::MDDF));
if (!(doodadDef.Flags & 0x40))
{
Doodad::Extract(doodadDef, ModelInstanceNames[doodadDef.Id].c_str(), map_num, originalMapId, dirfile, dirfileCache);
}
else
{
std::string fileName = Trinity::StringFormat("FILE%08X.xxx", doodadDef.Id);
ExtractSingleModel(fileName);
Doodad::Extract(doodadDef, fileName.c_str(), map_num, originalMapId, dirfile, dirfileCache);
}
}
ModelInstanceNames.clear();
}
}
else if (!strcmp(fourcc,"MODF"))
{
if (size)
{
uint32 mapObjectCount = size / sizeof(ADT::MODF);
for (uint32 i = 0; i < mapObjectCount; ++i)
{
ADT::MODF mapObjDef;
_file.read(&mapObjDef, sizeof(ADT::MODF));
if (!(mapObjDef.Flags & 0x8))
{
MapObject::Extract(mapObjDef, WmoInstanceNames[mapObjDef.Id].c_str(), false, map_num, originalMapId, dirfile, dirfileCache);
Doodad::ExtractSet(WmoDoodads[WmoInstanceNames[mapObjDef.Id]], mapObjDef, false, map_num, originalMapId, dirfile, dirfileCache);
}
else
{
std::string fileName = Trinity::StringFormat("FILE%08X.xxx", mapObjDef.Id);
ExtractSingleWmo(fileName);
MapObject::Extract(mapObjDef, fileName.c_str(), false, map_num, originalMapId, dirfile, dirfileCache);
Doodad::ExtractSet(WmoDoodads[fileName], mapObjDef, false, map_num, originalMapId, dirfile, dirfileCache);
}
}
WmoInstanceNames.clear();
}
}
//======================
_file.seek(nextpos);
}
_file.close();
fclose(dirfile);
return true;
}
bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
{
if(ADT.isEof())
return false;
uint32 size;
string xMap;
string yMap;
Adtfilename.erase(Adtfilename.find(".adt"),4);
string TempMapNumber;
TempMapNumber = Adtfilename.substr(Adtfilename.length()-6,6);
xMap = TempMapNumber.substr(TempMapNumber.find("_")+1,(TempMapNumber.find_last_of("_")-1) - (TempMapNumber.find("_")));
yMap = TempMapNumber.substr(TempMapNumber.find_last_of("_")+1,(TempMapNumber.length()) - (TempMapNumber.find_last_of("_")));
Adtfilename.erase((Adtfilename.length()-xMap.length()-yMap.length()-2), (xMap.length()+yMap.length()+2));
//string AdtMapNumber = xMap + ' ' + yMap + ' ' + GetPlainName((char*)Adtfilename.c_str());
//printf("Processing map %s...\n", AdtMapNumber.c_str());
//printf("MapNumber = %s\n", TempMapNumber.c_str());
//printf("xMap = %s\n", xMap.c_str());
//printf("yMap = %s\n", yMap.c_str());
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE *dirfile;
dirfile = fopen(dirname.c_str(), "ab");
if(!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
while (!ADT.isEof())
{
char fourcc[5];
ADT.read(&fourcc,4);
ADT.read(&size, 4);
flipcc(fourcc);
fourcc[4] = 0;
size_t nextpos = ADT.getPos() + size;
if (!strcmp(fourcc,"MCIN"))
{
}
else if (!strcmp(fourcc,"MTEX"))
{
}
else if (!strcmp(fourcc,"MMDX"))
{
if (size)
{
char* buf = new char[size];
ADT.read(buf, size);
char* p = buf;
int t = 0;
ModelInstanceNames = new std::string[size];
while (p < buf + size)
{
std::string path(p);
char* s = GetPlainName(p);
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
ModelInstanceNames[t++] = s;
ExtractSingleModel(path);
p += strlen(p) + 1;
}
delete[] buf;
}
}
else if (!strcmp(fourcc,"MWMO"))
{
if (size)
{
char* buf = new char[size];
ADT.read(buf, size);
char* p = buf;
int q = 0;
WmoInstanceNames = new std::string[size];
while (p < buf + size)
{
std::string path(p);
char* s = GetPlainName(p);
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
WmoInstanceNames[q++] = s;
ExtractSingleWmo(path);
p += strlen(p) + 1;
}
delete[] buf;
}
}
//======================
else if (!strcmp(fourcc,"MDDF"))
{
if (size)
{
nMDX = (int)size / 36;
for (int i = 0; i < nMDX; ++i)
{
uint32 id;
ADT.read(&id, 4);
ModelInstance inst(ADT, ModelInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
}
delete[] ModelInstanceNames;
ModelInstanceNames = NULL;
}
}
else if (!strcmp(fourcc,"MODF"))
{
if (size)
{
nWMO = (int)size / 64;
for (int i = 0; i < nWMO; ++i)
{
uint32 id;
ADT.read(&id, 4);
WMOInstance inst(ADT, WmoInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
}
delete[] WmoInstanceNames;
WmoInstanceNames = NULL;
}
}
//======================
ADT.seek(nextpos);
}
ADT.close();
fclose(dirfile);
return true;
}
void ExtractGameobjectModels(int iCoreNumber, const void *szRawVMAPMagic)
{
printf("\n");
printf("Extracting GameObject models...\n");
DBCFile dbc("DBFilesClient\\GameObjectDisplayInfo.dbc");
if (!dbc.open())
{
printf("Fatal error: Invalid GameObjectDisplayInfo.dbc file format!\n");
exit(1);
}
std::string basepath = szWorkDirWmo;
basepath += "/";
std::string path;
StringSet failedPaths;
FILE* model_list = fopen((basepath + "temp_gameobject_models").c_str(), "wb");
for (DBCFile::Iterator it = dbc.begin(); it != dbc.end(); ++it)
{
path = it->getString(1);
if (path.length() < 4)
{ continue; }
string name;
string ch_ext = GetExtension(path);
if (ch_ext.empty())
{ continue; }
bool result = false;
if (ch_ext == "wmo")
{
name = GetUniformName(path);
result = ExtractSingleWmo(path, iCoreNumber, szRawVMAPMagic);
}
else
{
result = ExtractSingleModel(path, name, failedPaths, iCoreNumber, szRawVMAPMagic);
}
if (result && FileExists((basepath + name).c_str()))
{
uint32 displayId = it->getUInt(0);
uint32 path_length = name.length();
fwrite(&displayId, sizeof(uint32), 1, model_list);
fwrite(&path_length, sizeof(uint32), 1, model_list);
fwrite(name.c_str(), sizeof(char), path_length, model_list);
}
}
fclose(model_list);
if (!failedPaths.empty())
{
printf("\n Warning: Some models could not be extracted, see below\n");
for (StringSet::const_iterator itr = failedPaths.begin(); itr != failedPaths.end(); ++itr)
{ printf(" Could not find file of model %s\n", itr->c_str()); }
printf("\n A few of these warnings are expected to happen, so be not alarmed!\n");
}
printf("\n Asset Extraction Complete !\n");
}
bool WDTFile::init(uint32 mapId)
{
if (_file.isEof())
return false;
char fourcc[5];
uint32 size;
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE* dirfile = fopen(dirname.c_str(), "ab");
if (!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
while (!_file.isEof())
{
_file.read(fourcc,4);
_file.read(&size, 4);
flipcc(fourcc);
fourcc[4] = 0;
size_t nextpos = _file.getPos() + size;
if (!strcmp(fourcc,"MAIN"))
{
}
if (!strcmp(fourcc,"MWMO"))
{
// global map objects
if (size)
{
char *buf = new char[size];
_file.read(buf, size);
char *p = buf;
while (p < buf + size)
{
std::string path(p);
char* s = wdtGetPlainName(p);
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
p = p + strlen(p) + 1;
_wmoNames.push_back(s);
ExtractSingleWmo(path);
}
delete[] buf;
}
}
else if (!strcmp(fourcc, "MODF"))
{
// global wmo instance data
if (size)
{
int32 gnWMO = (int)size / 64;
for (int i = 0; i < gnWMO; ++i)
{
int id;
_file.read(&id, 4);
WMOInstance inst(_file, _wmoNames[id].c_str(), mapId, 65, 65, mapId, dirfile, nullptr);
}
}
}
_file.seek((int)nextpos);
}
_file.close();
fclose(dirfile);
return true;
}
void ExtractGameobjectModels(char* input_path)
{
HANDLE localeFile;
char localMPQ[512];
sprintf(localMPQ, "%smisc.MPQ", input_path);
if (FileExists(localMPQ)==false)
{ // Use misc.mpq
printf(localMPQ, "%s/Data/%s/locale-%s.MPQ", input_path);
}
if (!SFileOpenArchive(localMPQ, 0, MPQ_OPEN_READ_ONLY, &localeFile))
{
exit(1);
}
printf("Extracting GameObject models...");
DBCFile dbc(localeFile, "DBFilesClient\\GameObjectDisplayInfo.dbc");
if(!dbc.open())
{
printf("Fatal error: Invalid GameObjectDisplayInfo.dbc file format!\n");
exit(1);
}
std::string basepath = szWorkDirWmo;
basepath += "/";
std::string path;
FILE * model_list = fopen((basepath + "temp_gameobject_models").c_str(), "wb");
for (DBCFile::Iterator it = dbc.begin(); it != dbc.end(); ++it)
{
path = it->getString(1);
if (path.length() < 4)
continue;
FixNameCase((char*)path.c_str(), path.size());
char * name = GetPlainName((char*)path.c_str());
FixNameSpaces(name, strlen(name));
char * ch_ext = GetExtension(name);
if (!ch_ext)
continue;
strToLower(ch_ext);
bool result = false;
if (!strcmp(ch_ext, ".wmo"))
result = ExtractSingleWmo(path);
else if (!strcmp(ch_ext, ".mdl")) // TODO: extract .mdl files, if needed
continue;
else //if (!strcmp(ch_ext, ".mdx") || !strcmp(ch_ext, ".m2"))
result = ExtractSingleModel(path);
if (result)
{
uint32 displayId = it->getUInt(0);
uint32 path_length = strlen(name);
fwrite(&displayId, sizeof(uint32), 1, model_list);
fwrite(&path_length, sizeof(uint32), 1, model_list);
fwrite(name, sizeof(char), path_length, model_list);
}
}
fclose(model_list);
printf("Done!\n");
}