VMAP::TileAssembler Class Reference

#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)
void	setModelNameFilterMethod (bool(*pFilterMethod)(char *pName))
std::string	getDirEntryNameFromModName (unsigned int pMapId, const std::string &pModPosName)

Private Attributes
std::string	iDestDir
std::string	iSrcDir
bool(*	iFilterMethod )(char *pName)
G3D::Table< std::string, unsigned int >	iUniqueNameIds
unsigned int	iCurrentUniqueNameId
MapData	mapData
std::set< std::string >	spawnedModelFiles

Constructor & Destructor Documentation

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

 : iDestDir(pDestDirName), iSrcDir(pSrcDirName), iFilterMethod(NULL), iCurrentUniqueNameId(0)
 {
 //mkdir(iDestDir);
 //init();
 }

VMAP::TileAssembler::~TileAssembler ( )

virtual

 {
 //delete iCoordModelMapping;
 }

Member Function Documentation

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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(4) << 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(4) << 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void VMAP::TileAssembler::exportGameobjectModels

(

)

 {
 FILE* model_list = fopen((iSrcDir + "/" + "temp_gameobject_models").c_str(), "rb");
 if (!model_list)
 return;

 FILE* model_list_copy = fopen((iDestDir + "/" + GAMEOBJECT_MODELS).c_str(), "wb");
 if (!model_list_copy)
 {
 fclose(model_list);
 return;
 }

 uint32 name_length, displayId;
 char buff[500];
 while (true)
 {
 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(&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);
 }
 }

 if (bounds.isEmpty())
 {
 std::cout << "\nModel " << std::string(buff, name_length) << " has empty bounding box" << std::endl;
 continue;
 }

 if (!bounds.isFinite())
 {
 std::cout << "\nModel " << std::string(buff, name_length) << " has invalid bounding box" << std::endl;
 continue;
 }

 fwrite(&displayId, sizeof(uint32), 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string VMAP::TileAssembler::getDirEntryNameFromModName	(	unsigned int	pMapId,
		const std::string &	pModPosName
	)

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))
 {
 check = 0;
 // read mapID, tileX, tileY, Flags, adtID, ID, 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 %u\n", mapID);
 mapData[mapID] = current = new MapSpawns();
 }
 else current = (*map_iter).second;
 current->UniqueEntries.insert(pair<uint32, ModelSpawn>(spawn.ID, spawn));
 current->TileEntries.insert(pair<uint32, uint32>(StaticMapTree::packTileID(tileX, tileY), spawn.ID));
 }
 bool success = (ferror(dirf) == 0);
 fclose(dirf);
 return success;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void VMAP::TileAssembler::setModelNameFilterMethod ( bool(*)(char *pName)  pFilterMethod )

inline

{ iFilterMethod = pFilterMethod; }

Member Data Documentation

unsigned int VMAP::TileAssembler::iCurrentUniqueNameId

private

std::string VMAP::TileAssembler::iDestDir

private

bool(* VMAP::TileAssembler::iFilterMethod)(char *pName)

private

std::string VMAP::TileAssembler::iSrcDir

private

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

private

MapData VMAP::TileAssembler::mapData

private

std::set<std::string> VMAP::TileAssembler::spawnedModelFiles

private

---

The documentation for this class was generated from the following files:

• src/common/Collision/Maps/TileAssembler.h
• src/common/Collision/Maps/TileAssembler.cpp