#include "TileAssembler.h"

Public Member Functions
	TileAssembler (const std::string &pSrcDirName, const std::string &pDestDirName)

virtual	~TileAssembler ()

bool	convertWorld2 ()

bool	readMapSpawns ()

bool	calculateTransformedBound (ModelSpawn &spawn)

void	exportGameobjectModels ()

bool	convertRawFile (const std::string &pModelFilename)

Private Attributes
std::string	iDestDir

std::string	iSrcDir

G3D::Table< std::string, unsigned int >	iUniqueNameIds

MapData	mapData

std::set< std::string >	spawnedModelFiles

Detailed Description

Constructor & Destructor Documentation

◆ TileAssembler()

VMAP::TileAssembler::TileAssembler	(	const std::string &	pSrcDirName,
		const std::string &	pDestDirName
	)

        : iDestDir(pDestDirName), iSrcDir(pSrcDirName)
    {
        boost::filesystem::create_directory(iDestDir);
        //init();
    }

References iDestDir.

◆ ~TileAssembler()

VMAP::TileAssembler::~TileAssembler ( )

virtual

    {
        //delete iCoordModelMapping;
    }

Member Function Documentation

◆ calculateTransformedBound()

bool VMAP::TileAssembler::calculateTransformedBound ( ModelSpawn & spawn )

    {
        std::string modelFilename(iSrcDir);
        modelFilename.push_back('/');
        modelFilename.append(spawn.name);
 
        ModelPosition modelPosition;
        modelPosition.iDir = spawn.iRot;
        modelPosition.iScale = spawn.iScale;
        modelPosition.init();
 
        WorldModel_Raw raw_model;
        if (!raw_model.Read(modelFilename.c_str()))
        {
            return false;
        }
 
        uint32 groups = raw_model.groupsArray.size();
        if (groups != 1)
        {
            printf("Warning: '%s' does not seem to be a M2 model!\n", modelFilename.c_str());
        }
 
        AABox modelBound;
        bool boundEmpty = true;
 
        for (uint32 g = 0; g < groups; ++g) // should be only one for M2 files...
        {
            std::vector<Vector3>& vertices = raw_model.groupsArray[g].vertexArray;
 
            if (vertices.empty())
            {
                std::cout << "error: model '" << spawn.name << "' has no geometry!" << std::endl;
                continue;
            }
 
            uint32 nvectors = vertices.size();
            for (uint32 i = 0; i < nvectors; ++i)
            {
                Vector3 v = modelPosition.transform(vertices[i]);
 
                if (boundEmpty)
                {
                    modelBound = AABox(v, v), boundEmpty = false;
                }
                else
                {
                    modelBound.merge(v);
                }
            }
        }
        spawn.iBound = modelBound + spawn.iPos;
        spawn.flags |= MOD_HAS_BOUND;
        return true;
    }

References VMAP::ModelSpawn::flags, VMAP::WorldModel_Raw::groupsArray, VMAP::ModelSpawn::iBound, VMAP::ModelPosition::iDir, VMAP::ModelPosition::init(), VMAP::ModelSpawn::iPos, VMAP::ModelSpawn::iRot, VMAP::ModelPosition::iScale, VMAP::ModelSpawn::iScale, iSrcDir, VMAP::MOD_HAS_BOUND, VMAP::ModelSpawn::name, VMAP::WorldModel_Raw::Read(), and VMAP::ModelPosition::transform().

Referenced by convertWorld2().

◆ convertRawFile()

bool VMAP::TileAssembler::convertRawFile ( const std::string & pModelFilename )

    {
        bool success = true;
        std::string filename = iSrcDir;
        if (filename.length() > 0)
        {
            filename.push_back('/');
        }
        filename.append(pModelFilename);
 
        WorldModel_Raw raw_model;
        if (!raw_model.Read(filename.c_str()))
        {
            return false;
        }
 
        // write WorldModel
        WorldModel model;
        model.setRootWmoID(raw_model.RootWMOID);
        if (!raw_model.groupsArray.empty())
        {
            std::vector<GroupModel> groupsArray;
 
            uint32 groups = raw_model.groupsArray.size();
            for (uint32 g = 0; g < groups; ++g)
            {
                GroupModel_Raw& raw_group = raw_model.groupsArray[g];
                groupsArray.push_back(GroupModel(raw_group.mogpflags, raw_group.GroupWMOID, raw_group.bounds ));
                groupsArray.back().setMeshData(raw_group.vertexArray, raw_group.triangles);
                groupsArray.back().setLiquidData(raw_group.liquid);
            }
 
            model.setGroupModels(groupsArray);
        }
 
        success = model.writeFile(iDestDir + "/" + pModelFilename + ".vmo");
        //std::cout << "readRawFile2: '" << pModelFilename << "' tris: " << nElements << " nodes: " << nNodes << std::endl;
        return success;
    }

References VMAP::GroupModel_Raw::bounds, VMAP::WorldModel_Raw::groupsArray, VMAP::GroupModel_Raw::GroupWMOID, iDestDir, iSrcDir, VMAP::GroupModel_Raw::liquid, VMAP::GroupModel_Raw::mogpflags, VMAP::WorldModel_Raw::Read(), VMAP::WorldModel_Raw::RootWMOID, VMAP::WorldModel::setGroupModels(), VMAP::WorldModel::setRootWmoID(), VMAP::GroupModel_Raw::triangles, VMAP::GroupModel_Raw::vertexArray, and VMAP::WorldModel::writeFile().

Referenced by convertWorld2().

◆ convertWorld2()

bool VMAP::TileAssembler::convertWorld2 ( )

Todo:: remove extractor hack and uncomment below line:

    {
        bool success = readMapSpawns();
        if (!success)
        {
            return false;
        }
 
        // export Map data
        for (MapData::iterator map_iter = mapData.begin(); map_iter != mapData.end() && success; ++map_iter)
        {
            // build global map tree
            std::vector<ModelSpawn*> mapSpawns;
            UniqueEntryMap::iterator entry;
            printf("Calculating model bounds for map %u...\n", map_iter->first);
            for (entry = map_iter->second->UniqueEntries.begin(); entry != map_iter->second->UniqueEntries.end(); ++entry)
            {
                // M2 models don't have a bound set in WDT/ADT placement data, i still think they're not used for LoS at all on retail
                if (entry->second.flags & MOD_M2)
                {
                    if (!calculateTransformedBound(entry->second))
                    {
                        break;
                    }
                }
                else if (entry->second.flags & MOD_WORLDSPAWN) // WMO maps and terrain maps use different origin, so we need to adapt :/
                {
                    //entry->second.iPos += Vector3(533.33333f*32, 533.33333f*32, 0.f);
                    entry->second.iBound = entry->second.iBound + Vector3(533.33333f * 32, 533.33333f * 32, 0.f);
                }
                mapSpawns.push_back(&(entry->second));
                spawnedModelFiles.insert(entry->second.name);
            }
 
            printf("Creating map tree for map %u...\n", map_iter->first);
            BIH pTree;
 
            try
            {
                pTree.build(mapSpawns, BoundsTrait<ModelSpawn*>::GetBounds);
            }
            catch (std::exception& e)
            {
                printf("Exception ""%s"" when calling pTree.build", e.what());
                return false;
            }
 
            // ===> possibly move this code to StaticMapTree class
            std::map<uint32, uint32> modelNodeIdx;
            for (uint32 i = 0; i < mapSpawns.size(); ++i)
            {
                modelNodeIdx.insert(pair<uint32, uint32>(mapSpawns[i]->ID, i));
            }
 
            // write map tree file
            std::stringstream mapfilename;
            mapfilename << iDestDir << '/' << std::setfill('0') << std::setw(3) << map_iter->first << ".vmtree";
            FILE* mapfile = fopen(mapfilename.str().c_str(), "wb");
            if (!mapfile)
            {
                success = false;
                printf("Cannot open %s\n", mapfilename.str().c_str());
                break;
            }
 
            //general info
            if (success && fwrite(VMAP_MAGIC, 1, 8, mapfile) != 8) { success = false; }
            uint32 globalTileID = StaticMapTree::packTileID(65, 65);
            pair<TileMap::iterator, TileMap::iterator> globalRange = map_iter->second->TileEntries.equal_range(globalTileID);
            char isTiled = globalRange.first == globalRange.second; // only maps without terrain (tiles) have global WMO
            if (success && fwrite(&isTiled, sizeof(char), 1, mapfile) != 1) { success = false; }
            // Nodes
            if (success && fwrite("NODE", 4, 1, mapfile) != 1) { success = false; }
            if (success) { success = pTree.writeToFile(mapfile); }
            // global map spawns (WDT), if any (most instances)
            if (success && fwrite("GOBJ", 4, 1, mapfile) != 1) { success = false; }
 
            for (TileMap::iterator glob = globalRange.first; glob != globalRange.second && success; ++glob)
            {
                success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second]);
            }
 
            fclose(mapfile);
 
            // <====
 
            // write map tile files, similar to ADT files, only with extra BSP tree node info
            TileMap& tileEntries = map_iter->second->TileEntries;
            TileMap::iterator tile;
            for (tile = tileEntries.begin(); tile != tileEntries.end(); ++tile)
            {
                const ModelSpawn& spawn = map_iter->second->UniqueEntries[tile->second];
                if (spawn.flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
                {
                    continue;
                }
                uint32 nSpawns = tileEntries.count(tile->first);
                std::stringstream tilefilename;
                tilefilename.fill('0');
                tilefilename << iDestDir << '/' << std::setw(3) << map_iter->first << '_';
                uint32 x, y;
                StaticMapTree::unpackTileID(tile->first, x, y);
                tilefilename << std::setw(2) << x << '_' << std::setw(2) << y << ".vmtile";
                if (FILE* tilefile = fopen(tilefilename.str().c_str(), "wb"))
                {
                    // file header
                    if (success && fwrite(VMAP_MAGIC, 1, 8, tilefile) != 8) { success = false; }
                    // write number of tile spawns
                    if (success && fwrite(&nSpawns, sizeof(uint32), 1, tilefile) != 1) { success = false; }
                    // write tile spawns
                    for (uint32 s = 0; s < nSpawns; ++s)
                    {
                        if (s)
                        {
                            ++tile;
                        }
                        const ModelSpawn& spawn2 = map_iter->second->UniqueEntries[tile->second];
                        success = success && ModelSpawn::writeToFile(tilefile, spawn2);
                        // MapTree nodes to update when loading tile:
                        std::map<uint32, uint32>::iterator nIdx = modelNodeIdx.find(spawn2.ID);
                        if (success && fwrite(&nIdx->second, sizeof(uint32), 1, tilefile) != 1) { success = false; }
                    }
                    fclose(tilefile);
                }
            }
            // break; //test, extract only first map; TODO: remvoe this line
        }
 
        // add an object models, listed in temp_gameobject_models file
        exportGameobjectModels();
        // export objects
        std::cout << "\nConverting Model Files" << std::endl;
        for (std::set<std::string>::iterator mfile = spawnedModelFiles.begin(); mfile != spawnedModelFiles.end(); ++mfile)
        {
            std::cout << "Converting " << *mfile << std::endl;
            if (!convertRawFile(*mfile))
            {
                std::cout << "error converting " << *mfile << std::endl;
                success = false;
                break;
            }
        }
 
        //cleanup:
        for (MapData::iterator map_iter = mapData.begin(); map_iter != mapData.end(); ++map_iter)
        {
            delete map_iter->second;
        }
        return success;
    }

References BIH::build(), calculateTransformedBound(), convertRawFile(), exportGameobjectModels(), VMAP::ModelSpawn::flags, VMAP::ModelSpawn::ID, iDestDir, mapData, VMAP::MOD_M2, VMAP::MOD_WORLDSPAWN, VMAP::StaticMapTree::packTileID(), readMapSpawns(), spawnedModelFiles, VMAP::StaticMapTree::unpackTileID(), VMAP::VMAP_MAGIC, VMAP::ModelSpawn::writeToFile(), and BIH::writeToFile().

Referenced by main().

◆ exportGameobjectModels()

void VMAP::TileAssembler::exportGameobjectModels ( )

    {
        FILE* model_list = fopen((iSrcDir + "/" + "temp_gameobject_models").c_str(), "rb");
        if (!model_list)
        {
            return;
        }
 
        char ident[8];
        if (fread(ident, 1, 8, model_list) != 8 || memcmp(ident, VMAP::RAW_VMAP_MAGIC, 8) != 0)
        {
            fclose(model_list);
            return;
        }
 
        FILE* model_list_copy = fopen((iDestDir + "/" + GAMEOBJECT_MODELS).c_str(), "wb");
        if (!model_list_copy)
        {
            fclose(model_list);
            return;
        }
 
        fwrite(VMAP::VMAP_MAGIC, 1, 8, model_list_copy);
 
        uint32 name_length, displayId;
        uint8 isWmo;
        char buff[500];
        while (!feof(model_list))
        {
            if (fread(&displayId, sizeof(uint32), 1, model_list) != 1)
                if (feof(model_list))   // EOF flag is only set after failed reading attempt
                {
                    break;
                }
 
            if (fread(&isWmo, sizeof(uint8), 1, model_list) != 1
                    || fread(&name_length, sizeof(uint32), 1, model_list) != 1
                    || name_length >= sizeof(buff)
                    || fread(&buff, sizeof(char), name_length, model_list) != name_length)
            {
                std::cout << "\nFile 'temp_gameobject_models' seems to be corrupted" << std::endl;
                break;
            }
 
            std::string model_name(buff, name_length);
 
            WorldModel_Raw raw_model;
            if (!raw_model.Read((iSrcDir + "/" + model_name).c_str()))
            {
                continue;
            }
 
            spawnedModelFiles.insert(model_name);
            AABox bounds;
            bool boundEmpty = true;
            for (uint32 g = 0; g < raw_model.groupsArray.size(); ++g)
            {
                std::vector<Vector3>& vertices = raw_model.groupsArray[g].vertexArray;
 
                uint32 nvectors = vertices.size();
                for (uint32 i = 0; i < nvectors; ++i)
                {
                    Vector3& v = vertices[i];
                    if (boundEmpty)
                    {
                        bounds = AABox(v, v), boundEmpty = false;
                    }
                    else
                    {
                        bounds.merge(v);
                    }
                }
            }
 
            fwrite(&displayId, sizeof(uint32), 1, model_list_copy);
            fwrite(&isWmo, sizeof(uint8), 1, model_list_copy);
            fwrite(&name_length, sizeof(uint32), 1, model_list_copy);
            fwrite(&buff, sizeof(char), name_length, model_list_copy);
            fwrite(&bounds.low(), sizeof(Vector3), 1, model_list_copy);
            fwrite(&bounds.high(), sizeof(Vector3), 1, model_list_copy);
        }
 
        fclose(model_list);
        fclose(model_list_copy);
    }

References VMAP::GAMEOBJECT_MODELS, VMAP::WorldModel_Raw::groupsArray, iDestDir, iSrcDir, model_list, VMAP::RAW_VMAP_MAGIC, VMAP::WorldModel_Raw::Read(), spawnedModelFiles, and VMAP::VMAP_MAGIC.

Referenced by convertWorld2().

◆ readMapSpawns()

bool VMAP::TileAssembler::readMapSpawns ( )

    {
        std::string fname = iSrcDir + "/dir_bin";
        FILE* dirf = fopen(fname.c_str(), "rb");
        if (!dirf)
        {
            printf("Could not read dir_bin file!\n");
            return false;
        }
        printf("Read coordinate mapping...\n");
        uint32 mapID, tileX, tileY, check = 0;
        G3D::Vector3 v1, v2;
        ModelSpawn spawn;
        while (!feof(dirf))
        {
            // read mapID, tileX, tileY, Flags, NameSet, UniqueId, Pos, Rot, Scale, Bound_lo, Bound_hi, name
            check = fread(&mapID, sizeof(uint32), 1, dirf);
            if (check == 0) // EoF...
            {
                break;
            }
            check += fread(&tileX, sizeof(uint32), 1, dirf);
            check += fread(&tileY, sizeof(uint32), 1, dirf);
            if (!ModelSpawn::readFromFile(dirf, spawn))
            {
                break;
            }
 
            MapSpawns* current;
            MapData::iterator map_iter = mapData.find(mapID);
            if (map_iter == mapData.end())
            {
                printf("spawning Map %d\n", mapID);
                mapData[mapID] = current = new MapSpawns();
            }
            else
            {
                current = map_iter->second;
            }
 
            current->UniqueEntries.emplace(spawn.ID, spawn);
            current->TileEntries.insert(pair<uint32, uint32>(StaticMapTree::packTileID(tileX, tileY), spawn.ID));
        }
        bool success = (ferror(dirf) == 0);
        fclose(dirf);
        return success;
    }