vmapexport.h File Reference

#include "loadlib/loadlib.h"
#include <string>
#include <unordered_map>

Go to the source code of this file.

Namespaces
namespace	VMAP

Enumerations
enum	ModelFlags {   MOD_M2 = 1 ,   MOD_WORLDSPAWN = 1 << 1 ,   MOD_HAS_BOUND = 1 << 2 }

Functions
uint32	GenerateUniqueObjectId (uint32 clientId, uint16 clientDoodadId)
bool	FileExists (const char *file)
void	strToLower (char *str)
bool	ExtractSingleWmo (std::string &fname)
bool	ExtractSingleModel (std::string &fname)
void	ExtractGameobjectModels ()

Variables
const char *	szWorkDirWmo
std::unordered_map< std::string, WMODoodadData >	WmoDoodads

Enumeration Type Documentation

ModelFlags

enum ModelFlags

Enumerator
MOD_M2
MOD_WORLDSPAWN
MOD_HAS_BOUND

{
    MOD_M2 = 1,
    MOD_WORLDSPAWN = 1 << 1,
    MOD_HAS_BOUND = 1 << 2
};

Function Documentation

ExtractGameobjectModels()

void ExtractGameobjectModels

(

)

Todo:

: extract .mdl files, if needed

{
    printf("Extracting GameObject models...");
    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;
 
    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;
    }
 
    fwrite(VMAP::RAW_VMAP_MAGIC, 1, 8, model_list);
 
    for (const auto & it : dbc)
    {
        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;
        uint8 isWmo = 0;
        if (!strcmp(ch_ext, ".wmo"))
        {
            isWmo = 1;
            result = ExtractSingleWmo(path);
        }
        else if (!strcmp(ch_ext, ".mdl"))
        {
            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(&isWmo, sizeof(uint8), 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");
}

References ExtractSingleModel(), ExtractSingleWmo(), fixname2(), fixnamen(), GetExtension(), GetPlainName(), model_list, DBCFile::open(), VMAP::RAW_VMAP_MAGIC, strToLower(), and szWorkDirWmo.

Referenced by main().

ExtractSingleModel()

bool ExtractSingleModel

(

std::string &

fname

)

{
    if (fname.length() < 4)
        return false;
 
    std::string extension = fname.substr(fname.length() - 4, 4);
    if (extension == ".mdx" || extension == ".MDX" || extension == ".mdl" || extension == ".MDL")
    {
        // replace .mdx -> .m2
        fname.erase(fname.length() - 2, 2);
        fname.append("2");
    }
    // >= 3.1.0 ADT MMDX section store filename.m2 filenames for corresponded .m2 file
    // nothing do
 
    std::string originalName = fname;
 
    char* name = GetPlainName((char*)fname.c_str());
    fixnamen(name, strlen(name));
    fixname2(name, strlen(name));
 
    std::string output(szWorkDirWmo);
    output += "/";
    output += name;
 
    if (FileExists(output.c_str()))
        return true;
 
    Model mdl(originalName);
    if (!mdl.open())
        return false;
 
    return mdl.ConvertToVMAPModel(output.c_str());
}

References Model::ConvertToVMAPModel(), FileExists(), fixname2(), fixnamen(), GetPlainName(), Model::open(), and szWorkDirWmo.

Referenced by ExtractGameobjectModels(), ADTFile::init(), and WMORoot::open().

ExtractSingleWmo()

bool ExtractSingleWmo

(

std::string &

fname

)

{
    // Copy files from archive
    std::string originalName = fname;
 
    char szLocalFile[1024];
    char* plain_name = GetPlainName(&fname[0]);
    fixnamen(plain_name, strlen(plain_name));
    fixname2(plain_name, strlen(plain_name));
    sprintf(szLocalFile, "%s/%s", szWorkDirWmo, plain_name);
 
    if (FileExists(szLocalFile))
        return true;
 
    int p = 0;
    // Select root wmo files
    char const* rchr = strrchr(plain_name, '_');
    if (rchr != nullptr)
    {
        char cpy[4];
        memcpy(cpy, rchr, 4);
        for (int m : cpy)
        {
            if (isdigit(m))
                p++;
        }
    }
 
    if (p == 3)
        return true;
 
    bool file_ok = true;
    printf("Extracting %s\n", originalName.c_str());
    WMORoot froot(originalName);
    if (!froot.open())
    {
        printf("Couldn't open RootWmo!!!\n");
        return false;
    }
    FILE* output = fopen(szLocalFile, "wb");
    if (!output)
    {
        printf("couldn't open %s for writing!\n", szLocalFile);
        return false;
    }
    froot.ConvertToVMAPRootWmo(output);
    WMODoodadData& doodads = WmoDoodads[plain_name];
    std::swap(doodads, froot.DoodadData);
    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];
            int ret = snprintf(groupFileName, 1024, "%s_%03u.wmo", temp, i);
            if (ret < 0)
            {
                printf("Error when formatting string");
                return false;
            }
            //printf("Trying to open groupfile %s\n",groupFileName);
 
            string s = groupFileName;
            WMOGroup fgroup(s);
            if (!fgroup.open(&froot))
            {
                printf("Could not open all Group file for: %s\n", plain_name);
                file_ok = false;
                break;
            }
 
            Wmo_nVertices += fgroup.ConvertToVMAPGroupWmo(output, preciseVectorData);
            for (uint16 groupReference : fgroup.DoodadReferences)
            {
                if (groupReference >= doodads.Spawns.size())
                    continue;
 
                uint32 doodadNameIndex = doodads.Spawns[groupReference].NameIndex;
                if (froot.ValidDoodadNames.find(doodadNameIndex) == froot.ValidDoodadNames.end())
                    continue;
 
                doodads.References.insert(groupReference);
            }
        }
    }
 
    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;
}

References WMOGroup::ConvertToVMAPGroupWmo(), WMORoot::ConvertToVMAPRootWmo(), WMORoot::DoodadData, WMOGroup::DoodadReferences, FileExists(), fixname2(), fixnamen(), GetPlainName(), WMORoot::nGroups, WMORoot::open(), WMOGroup::open(), preciseVectorData, WMODoodadData::References, WMODoodadData::Spawns, szWorkDirWmo, WMORoot::ValidDoodadNames, and WmoDoodads.

Referenced by ExtractGameobjectModels(), ADTFile::init(), and WDTFile::init().

FileExists()

bool FileExists

(

const char *

file

)

{
    int fp = _open(FileName, OPEN_FLAGS);
    if (fp != -1)
    {
        _close(fp);
        return true;
    }
 
    return false;
}

References OPEN_FLAGS.

Referenced by ExtractDBCFiles(), ExtractSingleModel(), ExtractSingleWmo(), LoadCommonMPQFiles(), LoadLocaleMPQFiles(), and main().

GenerateUniqueObjectId()

uint32 GenerateUniqueObjectId	(	uint32	clientId,
		uint16	clientDoodadId
	)

{
    return uniqueObjectIds.emplace(std::make_pair(clientId, clientDoodadId), uint32(uniqueObjectIds.size() + 1)).first->second;
}

References uniqueObjectIds.

Referenced by Doodad::Extract(), MapObject::Extract(), and Doodad::ExtractSet().

strToLower()

void strToLower

(

char *

str

)

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

Variable Documentation

szWorkDirWmo

const char* szWorkDirWmo

extern

Referenced by Doodad::Extract(), MapObject::Extract(), ExtractGameobjectModels(), Doodad::ExtractSet(), ExtractSingleModel(), ExtractSingleWmo(), ADTFile::init(), WDTFile::init(), and main().

WmoDoodads

std::unordered_map<std::string, WMODoodadData> WmoDoodads

extern

Referenced by ExtractSingleWmo(), ADTFile::init(), and WDTFile::init().