vmapexport.cpp File Reference

#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <errno.h>
#include <sys/stat.h>
#include <map>
#include <fstream>
#include "Common.h"
#include "adtfile.h"
#include "wdtfile.h"
#include "dbcfile.h"
#include "wmo.h"
#include "mpqfile.h"
#include "vmapexport.h"
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>

Include dependency graph for vmapexport.cpp:

Classes
struct	map_id

Macros
#define	_CRT_SECURE_NO_DEPRECATE
#define	ERROR_PATH_NOT_FOUND   ERROR_FILE_NOT_FOUND
#define	MPQ_BLOCK_SIZE   0x1000
#define	CASC_LOCALES_COUNT   17

Functions
uint32	ReadBuild (int locale)
bool	OpenCascStorage (int locale)
bool	FileExists (const char *file)
void	strToLower (char *str)
void	ReadLiquidTypeTableDBC ()
bool	ExtractWmo ()
bool	ExtractSingleWmo (std::string &fname)
void	ParsMapFiles ()
bool	processArgv (int argc, char **argv, const char *versionString)
int	main (int argc, char **argv)

Variables
HANDLE	CascStorage = NULL
map_id *	map_ids
uint16 *	LiqType = 0
uint32	map_count
char	output_path [128] = "."
char	input_path [1024] = "."
bool	preciseVectorData = false
const char *	szWorkDirWmo = "./Buildings"
const char *	szRawVMAPMagic = "VMAP043"
char const *	CascLocaleNames [CASC_LOCALES_COUNT]
uint32	WowLocaleToCascLocaleFlags [12]

Macro Definition Documentation

#define _CRT_SECURE_NO_DEPRECATE

#define CASC_LOCALES_COUNT   17

#define ERROR_PATH_NOT_FOUND   ERROR_FILE_NOT_FOUND

#define MPQ_BLOCK_SIZE   0x1000

Function Documentation

bool ExtractSingleWmo

(

std::string &

fname

)

{
 // Copy files from archive

 char szLocalFile[1024];
 const char * plain_name = GetPlainName(fname.c_str());
 sprintf(szLocalFile, "%s/%s", szWorkDirWmo, plain_name);
 FixNameCase(szLocalFile,strlen(szLocalFile));

 if (FileExists(szLocalFile))
 return true;

 int p = 0;
 // Select root wmo files
 char const* rchr = strrchr(plain_name, '_');
 if (rchr != NULL)
 {
 char cpy[4];
 memcpy(cpy, rchr, 4);
 for (int i = 0; i < 4; ++i)
 {
 int m = cpy[i];
 if (isdigit(m))
 p++;
 }
 }

 if (p == 3)
 return true;

 bool file_ok = true;
 std::cout << "Extracting " << fname << std::endl;
 WMORoot froot(fname);
 if(!froot.open())
 {
 printf("Couldn't open RootWmo!!!\n");
 return true;
 }
 FILE *output = fopen(szLocalFile,"wb");
 if(!output)
 {
 printf("couldn't open %s for writing!\n", szLocalFile);
 return false;
 }
 froot.ConvertToVMAPRootWmo(output);
 int Wmo_nVertices = 0;
 //printf("root has %d groups\n", froot->nGroups);
 if (froot.nGroups !=0)
 {
 for (uint32 i = 0; i < froot.nGroups; ++i)
 {
 char temp[1024];
 strncpy(temp, fname.c_str(), 1024);
 temp[fname.length()-4] = 0;
 char groupFileName[1024];
 sprintf(groupFileName, "%s_%03u.wmo", temp, i);
 //printf("Trying to open groupfile %s\n",groupFileName);

 std::string s = groupFileName;
 WMOGroup fgroup(s);
 if(!fgroup.open())
 {
 printf("Could not open all Group file for: %s\n", plain_name);
 file_ok = false;
 break;
 }

 Wmo_nVertices += fgroup.ConvertToVMAPGroupWmo(output, &froot, preciseVectorData);
 }
 }

 fseek(output, 8, SEEK_SET); // store the correct no of vertices
 fwrite(&Wmo_nVertices,sizeof(int),1,output);
 fclose(output);

 // Delete the extracted file in the case of an error
 if (!file_ok)
 remove(szLocalFile);
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool FileExists

(

const char *

file

)

{
 if (FILE* n = fopen(file, "rb"))
 {
 fclose(n);
 return true;
 }
 return false;
}

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

{
 bool success = true;
 const char *versionString = "V4.03 2015_05";

 // Use command line arguments, when some
 if (!processArgv(argc, argv, versionString))
 return 1;

 // some simple check if working dir is dirty
 else
 {
 std::string sdir = std::string(szWorkDirWmo) + "/dir";
 std::string sdir_bin = std::string(szWorkDirWmo) + "/dir_bin";
 struct stat status;
 if (!stat(sdir.c_str(), &status) || !stat(sdir_bin.c_str(), &status))
 {
 printf("Your output directory seems to be polluted, please use an empty directory!\n");
 printf("<press return to exit>");
 char garbage[2];
 return scanf("%c", garbage);
 }
 }

 printf("Extract %s. Beginning work ....\n\n", versionString);
 //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 // Create the working directory
 if (mkdir(szWorkDirWmo
#if defined(__linux__) || defined(__APPLE__)
 , 0711
#endif
 ))
 success = (errno == EEXIST);

 int FirstLocale = -1;
 for (int i = 0; i < TOTAL_LOCALES; ++i)
 {
 if (i == LOCALE_none)
 continue;

 if (!OpenCascStorage(i))
 continue;

 FirstLocale = i;
 uint32 build = ReadBuild(i);
 if (!build)
 {
 CascCloseStorage(CascStorage);
 continue;
 }

 printf("Detected client build: %u\n\n", build);
 break;
 }

 if (!OpenCascStorage(FirstLocale))
 {
 if (GetLastError() != ERROR_PATH_NOT_FOUND)
 printf("Unable to open storage!\n");
 return 1;
 }

 // Extract models, listed in GameObjectDisplayInfo.dbc
 ExtractGameobjectModels();

 ReadLiquidTypeTableDBC();

 // extract data
 if (success)
 success = ExtractWmo();

 //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 //map.dbc
 if (success)
 {
 DBCFile * dbc = new DBCFile(CascStorage, "DBFilesClient\\Map.dbc");
 if (!dbc->open())
 {
 delete dbc;
 printf("FATAL ERROR: Map.dbc not found in data file.\n");
 return 1;
 }

 map_count = dbc->getRecordCount();
 map_ids = new map_id[map_count];
 for (unsigned int x = 0; x < map_count; ++x)
 {
 map_ids[x].id = dbc->getRecord(x).getUInt(0);

 const char* map_name = dbc->getRecord(x).getString(1);
 size_t max_map_name_length = sizeof(map_ids[x].name);
 if (strlen(map_name) >= max_map_name_length)
 {
 delete dbc;
 delete[] map_ids;
 printf("FATAL ERROR: Map name too long.\n");
 return 1;
 }

 strncpy(map_ids[x].name, map_name, max_map_name_length);
 map_ids[x].name[max_map_name_length - 1] = '\0';
 printf("Map - %s\n", map_ids[x].name);
 }

 delete dbc;
 ParsMapFiles();
 delete [] map_ids;
 }

 CascCloseStorage(CascStorage);

 printf("\n");
 if (!success)
 {
 printf("ERROR: Extract %s. Work NOT complete.\n Precise vector data=%d.\nPress any key.\n", versionString, preciseVectorData);
 getchar();
 }

 printf("Extract %s. Work complete. No errors.\n", versionString);
 delete [] LiqType;
 return 0;
}

Here is the call graph for this function:

bool OpenCascStorage

(

int

locale

)

{
 try
 {
 boost::filesystem::path const storage_dir(boost::filesystem::canonical(input_path) / "Data");
 if (!CascOpenStorage(storage_dir.string().c_str(), WowLocaleToCascLocaleFlags[locale], &CascStorage))
 {
 printf("error opening casc storage '%s' locale %s: %s\n", storage_dir.string().c_str(), localeNames[locale], HumanReadableCASCError(GetLastError()));
 return false;
 }
 printf("opened casc storage '%s' locale %s\n", storage_dir.string().c_str(), localeNames[locale]);
 return true;
 }
 catch (boost::filesystem::filesystem_error& error)
 {
 printf("error opening casc storage : %s\n", error.what());
 return false;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParsMapFiles

(

)

{
 char fn[512];
 //char id_filename[64];
 char id[10];
 for (unsigned int i=0; i<map_count; ++i)
 {
 sprintf(id, "%04u", map_ids[i].id);
 sprintf(fn,"World\\Maps\\%s\\%s.wdt", map_ids[i].name, map_ids[i].name);
 WDTFile WDT(fn,map_ids[i].name);
 if(WDT.init(id, map_ids[i].id))
 {
 printf("Processing Map %u\n[", map_ids[i].id);
 for (int x=0; x<64; ++x)
 {
 for (int y=0; y<64; ++y)
 {
 if (ADTFile *ADT = WDT.GetMap(x,y))
 {
 //sprintf(id_filename,"%02u %02u %03u",x,y,map_ids[i].id);//!!!!!!!!!
 ADT->init(map_ids[i].id, x, y);
 delete ADT;
 }
 }
 printf("#");
 fflush(stdout);
 }
 printf("]\n");
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool processArgv	(	int	argc,
		char **	argv,
		const char *	versionString
	)

{
 bool result = true;
 preciseVectorData = false;

 for(int i = 1; i < argc; ++i)
 {
 if(strcmp("-s",argv[i]) == 0)
 {
 preciseVectorData = false;
 }
 else if(strcmp("-d",argv[i]) == 0)
 {
 if((i+1)<argc)
 {
 strncpy(input_path, argv[i + 1], sizeof(input_path));
 input_path[sizeof(input_path) - 1] = '\0';

 if (input_path[strlen(input_path) - 1] != '\\' && input_path[strlen(input_path) - 1] != '/')
 strcat(input_path, "/");
 ++i;
 }
 else
 {
 result = false;
 }
 }
 else if(strcmp("-?",argv[1]) == 0)
 {
 result = false;
 }
 else if(strcmp("-l",argv[i]) == 0)
 {
 preciseVectorData = true;
 }
 else
 {
 result = false;
 break;
 }
 }

 if (!result)
 {
 printf("Extract %s.\n",versionString);
 printf("%s [-?][-s][-l][-d <path>]\n", argv[0]);
 printf(" -s : (default) small size (data size optimization), ~500MB less vmap data.\n");
 printf(" -l : large size, ~500MB more vmap data. (might contain more details)\n");
 printf(" -d <path>: Path to the vector data source folder.\n");
 printf(" -? : This message.\n");
 }

 return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 ReadBuild

(

int

locale

)

{
 // include build info file also
 std::string filename = std::string("component.wow-") + localeNames[locale] + ".txt";
 //printf("Read %s file... ", filename.c_str());

 HANDLE dbcFile;
 if (!CascOpenFile(CascStorage, filename.c_str(), CASC_LOCALE_ALL, 0, &dbcFile))
 {
 printf("Locale %s not installed.\n", localeNames[locale]);
 return 0;
 }

 char buff[512];
 DWORD readBytes = 0;
 CascReadFile(dbcFile, buff, 512, &readBytes);
 if (!readBytes)
 {
 printf("Fatal error: Not found %s file!\n", filename.c_str());
 exit(1);
 }

 std::string text = std::string(buff, readBytes);
 CascCloseFile(dbcFile);

 size_t pos = text.find("version=\"");
 size_t pos1 = pos + strlen("version=\"");
 size_t pos2 = text.find("\"", pos1);
 if (pos == text.npos || pos2 == text.npos || pos1 >= pos2)
 {
 printf("Fatal error: Invalid %s file format!\n", filename.c_str());
 exit(1);
 }

 std::string build_str = text.substr(pos1, pos2 - pos1);

 int build = atoi(build_str.c_str());
 if (build <= 0)
 {
 printf("Fatal error: Invalid %s file format!\n", filename.c_str());
 exit(1);
 }

 return build;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ReadLiquidTypeTableDBC

(

)

{
 printf("Read LiquidType.dbc file...");

 DBCFile dbc(CascStorage, "DBFilesClient\\LiquidType.dbc");
 if(!dbc.open())
 {
 printf("Fatal error: Invalid LiquidType.dbc file format!\n");
 exit(1);
 }

 size_t LiqType_count = dbc.getRecordCount();
 size_t LiqType_maxid = dbc.getRecord(LiqType_count - 1).getUInt(0);
 LiqType = new uint16[LiqType_maxid + 1];
 memset(LiqType, 0xff, (LiqType_maxid + 1) * sizeof(uint16));

 for(uint32 x = 0; x < LiqType_count; ++x)
 LiqType[dbc.getRecord(x).getUInt(0)] = dbc.getRecord(x).getUInt(3);

 printf("Done! (%u LiqTypes loaded)\n", (unsigned int)LiqType_count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void strToLower

(

char *

str

)

{
 while(*str)
 {
 *str=tolower(*str);
 ++str;
 }
}

Here is the caller graph for this function:

Variable Documentation

char const* CascLocaleNames[CASC_LOCALES_COUNT]

Initial value:

=
{
 "none", "enUS",
 "koKR", "unknown",
 "frFR", "deDE",
 "zhCN", "esES",
 "zhTW", "enGB",
 "enCN", "enTW",
 "esMX", "ruRU",
 "ptBR", "itIT",
 "ptPT"
}

HANDLE CascStorage = NULL

char input_path[1024] = "."

uint16* LiqType = 0

uint32 map_count

map_id* map_ids

char output_path[128] = "."

bool preciseVectorData = false

const char* szRawVMAPMagic = "VMAP043"

const char* szWorkDirWmo = "./Buildings"

uint32 WowLocaleToCascLocaleFlags[12]

Initial value:

=
{
 CASC_LOCALE_ENUS | CASC_LOCALE_ENGB,
 CASC_LOCALE_KOKR,
 CASC_LOCALE_FRFR,
 CASC_LOCALE_DEDE,
 CASC_LOCALE_ZHCN,
 CASC_LOCALE_ZHTW,
 CASC_LOCALE_ESES,
 CASC_LOCALE_ESMX,
 CASC_LOCALE_RURU,
 0,
 CASC_LOCALE_PTBR | CASC_LOCALE_PTPT,
 CASC_LOCALE_ITIT,
}