MMAP::MMapManager Class Reference

#include <MMapManager.h>

Public Types
typedef std::unordered_map < uint32, std::vector< uint32 > >	PhaseChildMapContainer

Public Member Functions
	MMapManager ()
	~MMapManager ()
void	InitializeThreadUnsafe (std::unordered_map< uint32, std::vector< uint32 >> const &mapData)
bool	loadMap (const std::string &basePath, uint32 mapId, int32 x, int32 y)
bool	unloadMap (uint32 mapId, int32 x, int32 y)
bool	unloadMap (uint32 mapId)
bool	unloadMapInstance (uint32 mapId, uint32 instanceId)
dtNavMeshQuery const *	GetNavMeshQuery (uint32 mapId, uint32 instanceId, TerrainSet swaps)
dtNavMesh const *	GetNavMesh (uint32 mapId, TerrainSet swaps)
uint32	getLoadedTilesCount () const
uint32	getLoadedMapsCount () const
void	LoadPhaseTiles (PhaseChildMapContainer::const_iterator phasedMapData, int32 x, int32 y)
void	UnloadPhaseTile (PhaseChildMapContainer::const_iterator phasedMapData, int32 x, int32 y)
PhaseTileContainer const *	GetPhaseTileContainer (uint32 mapId) const

Private Member Functions
bool	loadMapData (uint32 mapId)
uint32	packTileID (int32 x, int32 y)
MMapDataSet::const_iterator	GetMMapData (uint32 mapId) const
PhasedTile *	LoadTile (uint32 mapId, int32 x, int32 y)

Private Attributes
MMapDataSet	loadedMMaps
PhaseChildMapContainer	phaseMapData
uint32	loadedTiles
bool	thread_safe_environment
PhaseTileMap	_phaseTiles

Member Typedef Documentation

typedef std::unordered_map<uint32, std::vector<uint32> > MMAP::MMapManager::PhaseChildMapContainer

Constructor & Destructor Documentation

MMAP::MMapManager::MMapManager ( )

inline

: loadedTiles(0), thread_safe_environment(true) {}

MMAP::MMapManager::~MMapManager

(

)

 {
 for (MMapDataSet::iterator i = loadedMMaps.begin(); i != loadedMMaps.end(); ++i)
 delete i->second;

 // by now we should not have maps loaded
 // if we had, tiles in MMapData->mmapLoadedTiles, their actual data is lost!
 }

Member Function Documentation

uint32 MMAP::MMapManager::getLoadedMapsCount ( ) const

inline

{ return uint32(loadedMMaps.size()); }

Here is the caller graph for this function:

uint32 MMAP::MMapManager::getLoadedTilesCount ( ) const

inline

{ return loadedTiles; }

Here is the caller graph for this function:

MMapDataSet::const_iterator MMAP::MMapManager::GetMMapData ( uint32  mapId ) const

private

 {
 // return the iterator if found or end() if not found/NULL
 MMapDataSet::const_iterator itr = loadedMMaps.find(mapId);
 if (itr != loadedMMaps.cend() && !itr->second)
 itr = loadedMMaps.cend();

 return itr;
 }

Here is the caller graph for this function:

dtNavMesh const * MMAP::MMapManager::GetNavMesh	(	uint32	mapId,
		TerrainSet	swaps
	)

 {
 MMapDataSet::const_iterator itr = GetMMapData(mapId);
 if (itr == loadedMMaps.end())
 return NULL;

 return itr->second->GetNavMesh(swaps);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

dtNavMeshQuery const * MMAP::MMapManager::GetNavMeshQuery	(	uint32	mapId,
		uint32	instanceId,
		TerrainSet	swaps
	)

 {
 MMapDataSet::const_iterator itr = GetMMapData(mapId);
 if (itr == loadedMMaps.end())
 return NULL;

 MMapData* mmap = itr->second;
 if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
 {
 // allocate mesh query
 dtNavMeshQuery* query = dtAllocNavMeshQuery();
 ASSERT(query);
 if (dtStatusFailed(query->init(mmap->GetNavMesh(swaps), 1024)))
 {
 dtFreeNavMeshQuery(query);
 TC_LOG_ERROR("maps", "MMAP:GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId %04u instanceId %u", mapId, instanceId);
 return NULL;
 }

 TC_LOG_DEBUG("maps", "MMAP:GetNavMeshQuery: created dtNavMeshQuery for mapId %04u instanceId %u", mapId, instanceId);
 mmap->navMeshQueries.insert(std::pair<uint32, dtNavMeshQuery*>(instanceId, query));
 }

 return mmap->navMeshQueries[instanceId];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PhaseTileContainer const* MMAP::MMapManager::GetPhaseTileContainer ( uint32  mapId ) const

inline

 {
 auto itr = _phaseTiles.find(mapId);
 if (itr != _phaseTiles.end())
 return &itr->second;
 return nullptr;
 }

Here is the caller graph for this function:

void MMAP::MMapManager::InitializeThreadUnsafe

(

std::unordered_map< uint32, std::vector< uint32 >> const &

mapData

)

 {
 // the caller must pass the list of all mapIds that will be used in the MMapManager lifetime
 for (auto const& p : mapData)
 {
 loadedMMaps.insert(MMapDataSet::value_type(p.first, nullptr));
 if (!p.second.empty())
 {
 phaseMapData[p.first] = p.second;
 for (uint32 phasedMapId : p.second)
 _phaseTiles.insert(PhaseTileMap::value_type(phasedMapId, PhaseTileContainer()));
 }
 }

 thread_safe_environment = false;
 }

Here is the caller graph for this function:

bool MMAP::MMapManager::loadMap	(	const std::string &	basePath,
		uint32	mapId,
		int32	x,
		int32	y
	)

 {
 // make sure the mmap is loaded and ready to load tiles
 if (!loadMapData(mapId))
 return false;

 // get this mmap data
 MMapData* mmap = loadedMMaps[mapId];
 ASSERT(mmap->navMesh);

 // check if we already have this tile loaded
 uint32 packedGridPos = packTileID(x, y);
 if (mmap->loadedTileRefs.find(packedGridPos) != mmap->loadedTileRefs.end())
 return false;

 // load this tile :: mmaps/MMMMXXYY.mmtile
 std::string fileName = Trinity::StringFormat(TILE_FILE_NAME_FORMAT, sConfigMgr->GetStringDefault("DataDir", ".").c_str(), mapId, x, y);
 FILE* file = fopen(fileName.c_str(), "rb");
 if (!file)
 {
 TC_LOG_DEBUG("maps", "MMAP:loadMap: Could not open mmtile file '%s'", fileName.c_str());
 return false;
 }

 // read header
 MmapTileHeader fileHeader;
 if (fread(&fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || fileHeader.mmapMagic != MMAP_MAGIC)
 {
 TC_LOG_ERROR("maps", "MMAP:loadMap: Bad header in mmap %04u%02i%02i.mmtile", mapId, x, y);
 fclose(file);
 return false;
 }

 if (fileHeader.mmapVersion != MMAP_VERSION)
 {
 TC_LOG_ERROR("maps", "MMAP:loadMap: %04u%02i%02i.mmtile was built with generator v%i, expected v%i",
 mapId, x, y, fileHeader.mmapVersion, MMAP_VERSION);
 fclose(file);
 return false;
 }

 unsigned char* data = (unsigned char*)dtAlloc(fileHeader.size, DT_ALLOC_PERM);
 ASSERT(data);

 size_t result = fread(data, fileHeader.size, 1, file);
 if (!result)
 {
 TC_LOG_ERROR("maps", "MMAP:loadMap: Bad header or data in mmap %04u%02i%02i.mmtile", mapId, x, y);
 fclose(file);
 return false;
 }

 fclose(file);

 dtMeshHeader* header = (dtMeshHeader*)data;
 dtTileRef tileRef = 0;

 // memory allocated for data is now managed by detour, and will be deallocated when the tile is removed
 if (dtStatusSucceed(mmap->navMesh->addTile(data, fileHeader.size, DT_TILE_FREE_DATA, 0, &tileRef)))
 {
 mmap->loadedTileRefs.insert(std::pair<uint32, dtTileRef>(packedGridPos, tileRef));
 ++loadedTiles;
 TC_LOG_DEBUG("maps", "MMAP:loadMap: Loaded mmtile %04i[%02i, %02i] into %04i[%02i, %02i]", mapId, x, y, mapId, header->x, header->y);

 PhaseChildMapContainer::const_iterator phasedMaps = phaseMapData.find(mapId);
 if (phasedMaps != phaseMapData.end())
 LoadPhaseTiles(phasedMaps, x, y);

 return true;
 }

 TC_LOG_ERROR("maps", "MMAP:loadMap: Could not load %04u%02i%02i.mmtile into navmesh", mapId, x, y);
 dtFree(data);
 return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool MMAP::MMapManager::loadMapData ( uint32  mapId )

private

 {
 // we already have this map loaded?
 MMapDataSet::iterator itr = loadedMMaps.find(mapId);
 if (itr != loadedMMaps.end())
 {
 if (itr->second)
 return true;
 }
 else
 {
 if (thread_safe_environment)
 itr = loadedMMaps.insert(MMapDataSet::value_type(mapId, nullptr)).first;
 else
 ASSERT(false, "Invalid mapId %u passed to MMapManager after startup in thread unsafe environment", mapId);
 }

 // load and init dtNavMesh - read parameters from file
 std::string fileName = Trinity::StringFormat(MAP_FILE_NAME_FORMAT, sConfigMgr->GetStringDefault("DataDir", ".").c_str(), mapId);
 FILE* file = fopen(fileName.c_str(), "rb");
 if (!file)
 {
 TC_LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not open mmap file '%s'", fileName.c_str());
 return false;
 }

 dtNavMeshParams params;
 uint32 count = uint32(fread(&params, sizeof(dtNavMeshParams), 1, file));
 fclose(file);
 if (count != 1)
 {
 TC_LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not read params from file '%s'", fileName.c_str());
 return false;
 }

 dtNavMesh* mesh = dtAllocNavMesh();
 ASSERT(mesh);
 if (dtStatusFailed(mesh->init(&params)))
 {
 dtFreeNavMesh(mesh);
 TC_LOG_ERROR("maps", "MMAP:loadMapData: Failed to initialize dtNavMesh for mmap %04u from file %s", mapId, fileName.c_str());
 return false;
 }

 TC_LOG_DEBUG("maps", "MMAP:loadMapData: Loaded %04i.mmap", mapId);

 // store inside our map list
 MMapData* mmap_data = new MMapData(mesh, mapId);

 itr->second = mmap_data;
 return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void MMAP::MMapManager::LoadPhaseTiles	(	PhaseChildMapContainer::const_iterator	phasedMapData,
		int32	x,
		int32	y
	)

 {
 TC_LOG_DEBUG("phase", "MMAP:LoadPhaseTiles: Loading phased mmtiles for map %u, x: %i, y: %i", phasedMapData->first, x, y);

 uint32 packedGridPos = packTileID(x, y);

 for (uint32 phaseMapId : phasedMapData->second)
 {
 // only a few tiles have terrain swaps, do not write error for them
 if (PhasedTile* data = LoadTile(phaseMapId, x, y))
 {
 TC_LOG_DEBUG("phase", "MMAP:LoadPhaseTiles: Loaded phased %04u%02i%02i.mmtile for root phase map %u", phaseMapId, x, y, phasedMapData->first);
 _phaseTiles[phaseMapId][packedGridPos] = data;
 }
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PhasedTile * MMAP::MMapManager::LoadTile ( uint32  mapId, int32  x, int32  y  )

private

 {
 // load this tile :: mmaps/MMMXXYY.mmtile
 std::string fileName = Trinity::StringFormat(TILE_FILE_NAME_FORMAT, sConfigMgr->GetStringDefault("DataDir", ".").c_str(), mapId, x, y);
 FILE* file = fopen(fileName.c_str(), "rb");
 if (!file)
 {
 // Not all tiles have phased versions, don't flood this msg
 //TC_LOG_DEBUG("phase", "MMAP:LoadTile: Could not open mmtile file '%s'", fileName);
 return NULL;
 }

 PhasedTile* pTile = new PhasedTile();

 // read header
 if (fread(&pTile->fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || pTile->fileHeader.mmapMagic != MMAP_MAGIC)
 {
 TC_LOG_ERROR("phase", "MMAP:LoadTile: Bad header in mmap %04u%02i%02i.mmtile", mapId, x, y);
 fclose(file);
 delete pTile;
 return nullptr;
 }

 if (pTile->fileHeader.mmapVersion != MMAP_VERSION)
 {
 TC_LOG_ERROR("phase", "MMAP:LoadTile: %04u%02i%02i.mmtile was built with generator v%i, expected v%i",
 mapId, x, y, pTile->fileHeader.mmapVersion, MMAP_VERSION);
 fclose(file);
 delete pTile;
 return nullptr;
 }

 pTile->data = (unsigned char*)dtAlloc(pTile->fileHeader.size, DT_ALLOC_PERM);
 ASSERT(pTile->data);

 size_t result = fread(pTile->data, pTile->fileHeader.size, 1, file);
 if (!result)
 {
 TC_LOG_ERROR("phase", "MMAP:LoadTile: Bad header or data in mmap %04u%02i%02i.mmtile", mapId, x, y);
 fclose(file);
 delete pTile;
 return nullptr;
 }

 fclose(file);

 return pTile;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 MMAP::MMapManager::packTileID ( int32  x, int32  y  )

private

 {
 return uint32(x << 16 | y);
 }

Here is the caller graph for this function:

bool MMAP::MMapManager::unloadMap	(	uint32	mapId,
		int32	x,
		int32	y
	)

 {
 // check if we have this map loaded
 MMapDataSet::const_iterator itr = GetMMapData(mapId);
 if (itr == loadedMMaps.end())
 {
 // file may not exist, therefore not loaded
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map. %04u%02i%02i.mmtile", mapId, x, y);
 return false;
 }

 MMapData* mmap = itr->second;

 // check if we have this tile loaded
 uint32 packedGridPos = packTileID(x, y);
 if (mmap->loadedTileRefs.find(packedGridPos) == mmap->loadedTileRefs.end())
 {
 // file may not exist, therefore not loaded
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh tile. %04u%02i%02i.mmtile", mapId, x, y);
 return false;
 }

 dtTileRef tileRef = mmap->loadedTileRefs[packedGridPos];

 // unload, and mark as non loaded
 if (dtStatusFailed(mmap->navMesh->removeTile(tileRef, NULL, NULL)))
 {
 // this is technically a memory leak
 // if the grid is later reloaded, dtNavMesh::addTile will return error but no extra memory is used
 // we cannot recover from this error - assert out
 TC_LOG_ERROR("maps", "MMAP:unloadMap: Could not unload %04u%02i%02i.mmtile from navmesh", mapId, x, y);
 ABORT();
 }
 else
 {
 mmap->loadedTileRefs.erase(packedGridPos);
 --loadedTiles;
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded mmtile %03i[%02i, %02i] from %04i", mapId, x, y, mapId);

 PhaseChildMapContainer::const_iterator phasedMaps = phaseMapData.find(mapId);
 if (phasedMaps != phaseMapData.end())
 UnloadPhaseTile(phasedMaps, x, y);
 return true;
 }

 return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool MMAP::MMapManager::unloadMap

(

uint32

mapId

)

 {
 MMapDataSet::iterator itr = loadedMMaps.find(mapId);
 if (itr == loadedMMaps.end() || !itr->second)
 {
 // file may not exist, therefore not loaded
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map %04u", mapId);
 return false;
 }

 // unload all tiles from given map
 MMapData* mmap = itr->second;
 for (MMapTileSet::iterator i = mmap->loadedTileRefs.begin(); i != mmap->loadedTileRefs.end(); ++i)
 {
 uint32 x = (i->first >> 16);
 uint32 y = (i->first & 0x0000FFFF);
 if (dtStatusFailed(mmap->navMesh->removeTile(i->second, NULL, NULL)))
 TC_LOG_ERROR("maps", "MMAP:unloadMap: Could not unload %04u%02i%02i.mmtile from navmesh", mapId, x, y);
 else
 {
 PhaseChildMapContainer::const_iterator phasedMaps = phaseMapData.find(mapId);
 if (phasedMaps != phaseMapData.end())
 UnloadPhaseTile(phasedMaps, x, y);
 --loadedTiles;
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded mmtile %04i[%02i, %02i] from %04i", mapId, x, y, mapId);
 }
 }

 delete mmap;
 itr->second = nullptr;
 TC_LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded %04i.mmap", mapId);

 return true;
 }

Here is the call graph for this function:

bool MMAP::MMapManager::unloadMapInstance	(	uint32	mapId,
		uint32	instanceId
	)

 {
 // check if we have this map loaded
 MMapDataSet::const_iterator itr = GetMMapData(mapId);
 if (itr == loadedMMaps.end())
 {
 // file may not exist, therefore not loaded
 TC_LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded navmesh map %04u", mapId);
 return false;
 }

 MMapData* mmap = itr->second;
 if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
 {
 TC_LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded dtNavMeshQuery mapId %04u instanceId %u", mapId, instanceId);
 return false;
 }

 dtNavMeshQuery* query = mmap->navMeshQueries[instanceId];

 dtFreeNavMeshQuery(query);
 mmap->navMeshQueries.erase(instanceId);
 TC_LOG_DEBUG("maps", "MMAP:unloadMapInstance: Unloaded mapId %04u instanceId %u", mapId, instanceId);

 return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void MMAP::MMapManager::UnloadPhaseTile	(	PhaseChildMapContainer::const_iterator	phasedMapData,
		int32	x,
		int32	y
	)

 {
 TC_LOG_DEBUG("phase", "MMAP:UnloadPhaseTile: Unloading phased mmtile for map %u, x: %i, y: %i", phasedMapData->first, x, y);

 uint32 packedGridPos = packTileID(x, y);

 for (uint32 phaseMapId : phasedMapData->second)
 {
 auto phasedTileItr = _phaseTiles.find(phaseMapId);
 if (phasedTileItr == _phaseTiles.end())
 continue;

 auto dataItr = phasedTileItr->second.find(packedGridPos);
 if (dataItr != phasedTileItr->second.end())
 {
 TC_LOG_DEBUG("phase", "MMAP:UnloadPhaseTile: Unloaded phased %04u%02i%02i.mmtile for root phase map %u", phaseMapId, x, y, phasedMapData->first);
 delete dataItr->second->data;
 delete dataItr->second;
 phasedTileItr->second.erase(dataItr);
 }
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

PhaseTileMap MMAP::MMapManager::_phaseTiles

private

MMapDataSet MMAP::MMapManager::loadedMMaps

private

uint32 MMAP::MMapManager::loadedTiles

private

PhaseChildMapContainer MMAP::MMapManager::phaseMapData

private

bool MMAP::MMapManager::thread_safe_environment

private

---

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

• src/common/Collision/Management/MMapManager.h
• src/common/Collision/Management/MMapManager.cpp