MMAP::MMapMgr Class Reference

#include "MMapMgr.h"

Public Member Functions
	MMapMgr ()=default
	~MMapMgr ()
void	InitializeThreadUnsafe (const std::vector< uint32 > &mapIds)
bool	loadMap (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)
dtNavMesh const *	GetNavMesh (uint32 mapId)
uint32	getLoadedTilesCount () const
uint32	getLoadedMapsCount () const

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

Private Attributes
MMapDataSet	loadedMMaps
uint32	loadedTiles {0}
bool	thread_safe_environment {true}

Detailed Description

Constructor & Destructor Documentation

MMapMgr()

MMAP::MMapMgr::MMapMgr ( )

default

~MMapMgr()

MMAP::MMapMgr::~MMapMgr

(

)

    {
        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!
    }

References loadedMMaps.

Member Function Documentation

getLoadedMapsCount()

uint32 MMAP::MMapMgr::getLoadedMapsCount ( ) const

inline

{ return loadedMMaps.size(); }

References loadedMMaps.

Referenced by mmaps_commandscript::HandleMmapStatsCommand().

getLoadedTilesCount()

uint32 MMAP::MMapMgr::getLoadedTilesCount ( ) const

inline

{ return loadedTiles; }

References loadedTiles.

Referenced by mmaps_commandscript::HandleMmapStatsCommand().

GetMMapData()

MMapDataSet::const_iterator MMAP::MMapMgr::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;
    }

References loadedMMaps.

Referenced by GetNavMesh(), GetNavMeshQuery(), unloadMap(), and unloadMapInstance().

GetNavMesh()

dtNavMesh const * MMAP::MMapMgr::GetNavMesh

(

uint32

mapId

)

    {
        MMapDataSet::const_iterator itr = GetMMapData(mapId);
        if (itr == loadedMMaps.end())
        {
            return nullptr;
        }
 
        return itr->second->navMesh;
    }

References GetMMapData(), and loadedMMaps.

Referenced by misc_commandscript::HandleGPSCommand(), mmaps_commandscript::HandleMmapLoadedTilesCommand(), mmaps_commandscript::HandleMmapLocCommand(), mmaps_commandscript::HandleMmapStatsCommand(), and PathGenerator::PathGenerator().

GetNavMeshQuery()

dtNavMeshQuery const * MMAP::MMapMgr::GetNavMeshQuery	(	uint32	mapId,
		uint32	instanceId
	)

    {
        MMapDataSet::const_iterator itr = GetMMapData(mapId);
        if (itr == loadedMMaps.end())
        {
            return nullptr;
        }
 
        MMapData* mmap = itr->second;
        if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
        {
            // check again after acquiring mutex
            if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
            {
                // allocate mesh query
                dtNavMeshQuery* query = dtAllocNavMeshQuery();
                ASSERT(query);
 
                if (dtStatusFailed(query->init(mmap->navMesh, 1024)))
                {
                    dtFreeNavMeshQuery(query);
                    LOG_ERROR("maps", "MMAP:GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId {:03} instanceId {}", mapId, instanceId);
                    return nullptr;
                }
 
                LOG_DEBUG("maps", "MMAP:GetNavMeshQuery: created dtNavMeshQuery for mapId {:03} instanceId {}", mapId, instanceId);
                mmap->navMeshQueries.insert(std::pair<uint32, dtNavMeshQuery*>(instanceId, query));
            }
        }
 
        return mmap->navMeshQueries[instanceId];
    }

References ASSERT, GetMMapData(), loadedMMaps, LOG_DEBUG, LOG_ERROR, MMAP::MMapData::navMesh, and MMAP::MMapData::navMeshQueries.

Referenced by mmaps_commandscript::HandleMmapLoadedTilesCommand(), mmaps_commandscript::HandleMmapLocCommand(), and PathGenerator::PathGenerator().

InitializeThreadUnsafe()

void MMAP::MMapMgr::InitializeThreadUnsafe

(

const std::vector< uint32 > &

mapIds

)

    {
        // the caller must pass the list of all mapIds that will be used in the VMapMgr2 lifetime
        for (const uint32& mapId : mapIds)
        {
            loadedMMaps.emplace(mapId, nullptr);
        }
 
        thread_safe_environment = false;
    }

References loadedMMaps, and thread_safe_environment.

Referenced by World::SetInitialWorldSettings().

loadMap()

bool MMAP::MMapMgr::loadMap	(	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())
        {
            LOG_ERROR("maps", "MMAP:loadMap: Asked to load already loaded navmesh tile. {:03}{:02}{:02}.mmtile", mapId, x, y);
            return false;
        }
 
        // load this tile :: mmaps/MMMXXYY.mmtile
        std::string fileName = Acore::StringFormat(TILE_FILE_NAME_FORMAT, sConfigMgr->GetOption<std::string>("DataDir", ".").c_str(), mapId, x, y);
        FILE* file = fopen(fileName.c_str(), "rb");
        if (!file)
        {
            LOG_DEBUG("maps", "MMAP:loadMap: Could not open mmtile file '{}'", fileName);
            return false;
        }
 
        // read header
        MmapTileHeader fileHeader;
        if (fread(&fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || fileHeader.mmapMagic != MMAP_MAGIC)
        {
            LOG_ERROR("maps", "MMAP:loadMap: Bad header in mmap {:03}{:02}{:02}.mmtile", mapId, x, y);
            fclose(file);
            return false;
        }
 
        if (fileHeader.mmapVersion != MMAP_VERSION)
        {
            LOG_ERROR("maps", "MMAP:loadMap: {:03}{:02}{:02}.mmtile was built with generator v{}, expected v{}",
                           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)
        {
            LOG_ERROR("maps", "MMAP:loadMap: Bad header or data in mmap {:03}{:02}{:02}.mmtile", mapId, x, y);
            fclose(file);
            return false;
        }
 
        fclose(file);
 
        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;
            dtMeshHeader* header = (dtMeshHeader*)data;
            LOG_DEBUG("maps", "MMAP:loadMap: Loaded mmtile {:03}[{:02},{:02}] into {:03}[{:02},{:02}]", mapId, x, y, mapId, header->x, header->y);
            return true;
        }
 
        LOG_ERROR("maps", "MMAP:loadMap: Could not load {:03}{:02}{:02}.mmtile into navmesh", mapId, x, y);
        dtFree(data);
        return false;
    }

References ASSERT, loadedMMaps, MMAP::MMapData::loadedTileRefs, loadedTiles, loadMapData(), LOG_DEBUG, LOG_ERROR, MMAP_MAGIC, MMAP_VERSION, MmapTileHeader::mmapMagic, MmapTileHeader::mmapVersion, MMAP::MMapData::navMesh, packTileID(), sConfigMgr, MmapTileHeader::size, Acore::StringFormat(), and MMAP::TILE_FILE_NAME_FORMAT.

Referenced by Map::LoadMMap().

loadMapData()

bool MMAP::MMapMgr::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
            {
                ABORT("Invalid mapId {} passed to MMapMgr after startup in thread unsafe environment", mapId);
            }
        }
 
        // load and init dtNavMesh - read parameters from file
        std::string fileName = Acore::StringFormat(MAP_FILE_NAME_FORMAT, sConfigMgr->GetOption<std::string>("DataDir", ".").c_str(), mapId);
 
        FILE* file = fopen(fileName.c_str(), "rb");
        if (!file)
        {
            LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not open mmap file '{}'", fileName);
            return false;
        }
 
        dtNavMeshParams params;
        uint32 count = uint32(fread(&params, sizeof(dtNavMeshParams), 1, file));
        fclose(file);
        if (count != 1)
        {
            LOG_DEBUG("maps", "MMAP:loadMapData: Error: Could not read params from file '{}'", fileName);
            return false;
        }
 
        dtNavMesh* mesh = dtAllocNavMesh();
        ASSERT(mesh);
        if (DT_SUCCESS != mesh->init(&params))
        {
            dtFreeNavMesh(mesh);
            LOG_ERROR("maps", "MMAP:loadMapData: Failed to initialize dtNavMesh for mmap {:03} from file {}", mapId, fileName);
            return false;
        }
 
        LOG_DEBUG("maps", "MMAP:loadMapData: Loaded {:03}.mmap", mapId);
 
        // store inside our map list
        MMapData* mmap_data = new MMapData(mesh);
        itr->second = mmap_data;
        return true;
    }

References ABORT, ASSERT, loadedMMaps, LOG_DEBUG, LOG_ERROR, MMAP::MAP_FILE_NAME_FORMAT, sConfigMgr, Acore::StringFormat(), and thread_safe_environment.

Referenced by loadMap().

packTileID()

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

private

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

Referenced by loadMap(), and unloadMap().

unloadMap() [1/2]

bool MMAP::MMapMgr::unloadMap

(

uint32

mapId

)

    {
        MMapDataSet::iterator itr = loadedMMaps.find(mapId);
        if (itr == loadedMMaps.end() || !itr->second)
        {
            // file may not exist, therefore not loaded
            LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map {:03}", mapId);
            return false;
        }
 
        // unload all tiles from given map
        MMapData* mmap = itr->second;
        for (auto& i : mmap->loadedTileRefs)
        {
            uint32 x = (i.first >> 16);
            uint32 y = (i.first & 0x0000FFFF);
 
            if (dtStatusFailed(mmap->navMesh->removeTile(i.second, nullptr, nullptr)))
            {
                LOG_ERROR("maps", "MMAP:unloadMap: Could not unload {:03}{:02}{:02}.mmtile from navmesh", mapId, x, y);
            }
            else
            {
                --loadedTiles;
                LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded mmtile {:03}[{:02},{:02}] from {:03}", mapId, x, y, mapId);
            }
        }
 
        delete mmap;
        itr->second = nullptr;
        LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded {:03}.mmap", mapId);
 
        return true;
    }

References loadedMMaps, MMAP::MMapData::loadedTileRefs, loadedTiles, LOG_DEBUG, LOG_ERROR, and MMAP::MMapData::navMesh.

unloadMap() [2/2]

bool MMAP::MMapMgr::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
            LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh map. {:03}{:02}{:02}.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
            LOG_DEBUG("maps", "MMAP:unloadMap: Asked to unload not loaded navmesh tile. {:03}{:02}{:02}.mmtile", mapId, x, y);
            return false;
        }
 
        dtTileRef tileRef = mmap->loadedTileRefs[packedGridPos];
 
        // unload, and mark as non loaded
        if (dtStatusFailed(mmap->navMesh->removeTile(tileRef, nullptr, nullptr)))
        {
            // 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
            LOG_ERROR("maps", "MMAP:unloadMap: Could not unload {:03}{:02}{:02}.mmtile from navmesh", mapId, x, y);
            ABORT();
        }
 
        mmap->loadedTileRefs.erase(packedGridPos);
        --loadedTiles;
        LOG_DEBUG("maps", "MMAP:unloadMap: Unloaded mmtile {:03}[{:02},{:02}] from {:03}", mapId, x, y, mapId);
        return true;
    }

References ABORT, GetMMapData(), loadedMMaps, MMAP::MMapData::loadedTileRefs, loadedTiles, LOG_DEBUG, LOG_ERROR, MMAP::MMapData::navMesh, and packTileID().

Referenced by Map::UnloadGrid().

unloadMapInstance()

bool MMAP::MMapMgr::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
            LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded navmesh map {:03}", mapId);
            return false;
        }
 
        MMapData* mmap = itr->second;
        if (mmap->navMeshQueries.find(instanceId) == mmap->navMeshQueries.end())
        {
            LOG_DEBUG("maps", "MMAP:unloadMapInstance: Asked to unload not loaded dtNavMeshQuery mapId {:03} instanceId {}", mapId, instanceId);
            return false;
        }
 
        dtNavMeshQuery* query = mmap->navMeshQueries[instanceId];
 
        dtFreeNavMeshQuery(query);
        mmap->navMeshQueries.erase(instanceId);
        LOG_DEBUG("maps", "MMAP:unloadMapInstance: Unloaded mapId {:03} instanceId {}", mapId, instanceId);
 
        return true;
    }

References GetMMapData(), loadedMMaps, LOG_DEBUG, and MMAP::MMapData::navMeshQueries.

Referenced by Map::~Map().

Member Data Documentation

loadedMMaps

MMapDataSet MMAP::MMapMgr::loadedMMaps

private

Referenced by getLoadedMapsCount(), GetMMapData(), GetNavMesh(), GetNavMeshQuery(), InitializeThreadUnsafe(), loadMap(), loadMapData(), unloadMap(), unloadMapInstance(), and ~MMapMgr().

loadedTiles

uint32 MMAP::MMapMgr::loadedTiles {0}

private

Referenced by getLoadedTilesCount(), loadMap(), and unloadMap().

thread_safe_environment

bool MMAP::MMapMgr::thread_safe_environment {true}

private

Referenced by InitializeThreadUnsafe(), and loadMapData().