VMAP::StaticMapTree Class Reference

#include "MapTree.h"

Public Member Functions
	StaticMapTree (uint32 mapID, const std::string &basePath)
	~StaticMapTree ()
	Make sure to call unloadMap() to unregister acquired model references before destroying.
bool	isInLineOfSight (const G3D::Vector3 &pos1, const G3D::Vector3 &pos2, ModelIgnoreFlags ignoreFlags) const
bool	GetObjectHitPos (const G3D::Vector3 &pos1, const G3D::Vector3 &pos2, G3D::Vector3 &pResultHitPos, float pModifyDist) const
float	getHeight (const G3D::Vector3 &pPos, float maxSearchDist) const
bool	GetAreaInfo (G3D::Vector3 &pos, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const
bool	GetLocationInfo (const G3D::Vector3 &pos, LocationInfo &info) const
bool	InitMap (const std::string &fname, VMapMgr2 *vm)
void	UnloadMap (VMapMgr2 *vm)
bool	LoadMapTile (uint32 tileX, uint32 tileY, VMapMgr2 *vm)
void	UnloadMapTile (uint32 tileX, uint32 tileY, VMapMgr2 *vm)
bool	isTiled () const
uint32	numLoadedTiles () const
void	GetModelInstances (ModelInstance *&models, uint32 &count)

Static Public Member Functions
static std::string	getTileFileName (uint32 mapID, uint32 tileX, uint32 tileY)
static uint32	packTileID (uint32 tileX, uint32 tileY)
static void	unpackTileID (uint32 ID, uint32 &tileX, uint32 &tileY)
static LoadResult	CanLoadMap (const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY)

Private Types
typedef std::unordered_map< uint32, bool >	loadedTileMap
typedef std::unordered_map< uint32, uint32 >	loadedSpawnMap

Private Member Functions
bool	GetIntersectionTime (const G3D::Ray &pRay, float &pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const

Private Attributes
uint32	iMapID
bool	iIsTiled
BIH	iTree
ModelInstance *	iTreeValues
uint32	iNTreeValues
loadedTileMap	iLoadedTiles
loadedSpawnMap	iLoadedSpawns
std::string	iBasePath

Detailed Description

Member Typedef Documentation

loadedSpawnMap

typedef std::unordered_map<uint32, uint32> VMAP::StaticMapTree::loadedSpawnMap

private

loadedTileMap

typedef std::unordered_map<uint32, bool> VMAP::StaticMapTree::loadedTileMap

private

Constructor & Destructor Documentation

StaticMapTree()

VMAP::StaticMapTree::StaticMapTree	(	uint32	mapID,
		const std::string &	basePath
	)

        : iMapID(mapID), iIsTiled(false), iTreeValues(0), iBasePath(basePath)
    {
        if (iBasePath.length() > 0 && iBasePath[iBasePath.length() - 1] != '/' && iBasePath[iBasePath.length() - 1] != '\\')
        {
            iBasePath.push_back('/');
        }
    }

References iBasePath.

~StaticMapTree()

VMAP::StaticMapTree::~StaticMapTree

(

)

Make sure to call unloadMap() to unregister acquired model references before destroying.

    {
        delete[] iTreeValues;
    }

References iTreeValues.

Member Function Documentation

CanLoadMap()

LoadResult VMAP::StaticMapTree::CanLoadMap ( const std::string &  basePath, uint32  mapID, uint32  tileX, uint32  tileY  )

static

    {
        std::string basePath = vmapPath;
        if (basePath.length() > 0 && basePath[basePath.length() - 1] != '/' && basePath[basePath.length() - 1] != '\\')
        {
            basePath.push_back('/');
        }
        std::string fullname = basePath + VMapMgr2::getMapFileName(mapID);
 
        LoadResult result = LoadResult::Success;
 
        FILE* rf = fopen(fullname.c_str(), "rb");
        if (!rf)
        {
            return LoadResult::FileNotFound;
        }
 
        char tiled;
        char chunk[8];
        if (!readChunk(rf, chunk, VMAP_MAGIC, 8) || fread(&tiled, sizeof(char), 1, rf) != 1)
        {
            fclose(rf);
            return LoadResult::VersionMismatch;
        }
        if (tiled)
        {
            std::string tilefile = basePath + getTileFileName(mapID, tileX, tileY);
            FILE* tf = fopen(tilefile.c_str(), "rb");
            if (!tf)
            {
                result = LoadResult::FileNotFound;
            }
            else
            {
                if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
                {
                    result = LoadResult::VersionMismatch;
                }
                fclose(tf);
            }
        }
        fclose(rf);
        return result;
    }

References VMAP::FileNotFound, VMAP::VMapMgr2::getMapFileName(), getTileFileName(), VMAP::readChunk(), VMAP::Success, VMAP::VersionMismatch, and VMAP::VMAP_MAGIC.

Referenced by VMAP::VMapMgr2::existsMap().

GetAreaInfo()

bool VMAP::StaticMapTree::GetAreaInfo	(	G3D::Vector3 &	pos,
		uint32 &	flags,
		int32 &	adtId,
		int32 &	rootId,
		int32 &	groupId
	)		const

    {
        AreaInfoCallback intersectionCallBack(iTreeValues);
        iTree.intersectPoint(pos, intersectionCallBack);
        if (intersectionCallBack.aInfo.result)
        {
            flags = intersectionCallBack.aInfo.flags;
            adtId = intersectionCallBack.aInfo.adtId;
            rootId = intersectionCallBack.aInfo.rootId;
            groupId = intersectionCallBack.aInfo.groupId;
            pos.z = intersectionCallBack.aInfo.ground_Z;
            return true;
        }
        return false;
    }

References VMAP::AreaInfo::adtId, VMAP::AreaInfoCallback::aInfo, VMAP::AreaInfo::flags, VMAP::AreaInfo::ground_Z, VMAP::AreaInfo::groupId, BIH::intersectPoint(), iTree, iTreeValues, VMAP::AreaInfo::result, and VMAP::AreaInfo::rootId.

getHeight()

float VMAP::StaticMapTree::getHeight	(	const G3D::Vector3 &	pPos,
		float	maxSearchDist
	)		const

    {
        float height = G3D::finf();
        Vector3 dir = Vector3(0, 0, -1);
        G3D::Ray ray(pPos, dir);   // direction with length of 1
        float maxDist = maxSearchDist;
        if (GetIntersectionTime(ray, maxDist, false, ModelIgnoreFlags::Nothing))
        {
            height = pPos.z - maxDist;
        }
        return (height);
    }

References GetIntersectionTime(), and VMAP::Nothing.

GetIntersectionTime()

bool VMAP::StaticMapTree::GetIntersectionTime ( const G3D::Ray &  pRay, float &  pMaxDist, bool  StopAtFirstHit, ModelIgnoreFlags  ignoreFlags  ) const

private

If intersection is found within pMaxDist, sets pMaxDist to intersection distance and returns true. Else, pMaxDist is not modified and returns false;

    {
        float distance = pMaxDist;
        MapRayCallback intersectionCallBack(iTreeValues, ignoreFlags);
        iTree.intersectRay(pRay, intersectionCallBack, distance, StopAtFirstHit);
        if (intersectionCallBack.didHit())
        {
            pMaxDist = distance;
        }
        return intersectionCallBack.didHit();
    }

References VMAP::MapRayCallback::didHit(), BIH::intersectRay(), iTree, and iTreeValues.

Referenced by getHeight(), GetObjectHitPos(), and isInLineOfSight().

GetLocationInfo()

bool VMAP::StaticMapTree::GetLocationInfo	(	const G3D::Vector3 &	pos,
		LocationInfo &	info
	)		const

    {
        LocationInfoCallback intersectionCallBack(iTreeValues, info);
        iTree.intersectPoint(pos, intersectionCallBack);
        return intersectionCallBack.result;
    }

References BIH::intersectPoint(), iTree, iTreeValues, and VMAP::LocationInfoCallback::result.

GetModelInstances()

void VMAP::StaticMapTree::GetModelInstances	(	ModelInstance *&	models,
		uint32 &	count
	)

    {
        models = iTreeValues;
        count = iNTreeValues;
    }

References iNTreeValues, and iTreeValues.

GetObjectHitPos()

bool VMAP::StaticMapTree::GetObjectHitPos	(	const G3D::Vector3 &	pos1,
		const G3D::Vector3 &	pos2,
		G3D::Vector3 &	pResultHitPos,
		float	pModifyDist
	)		const

When moving from pos1 to pos2 check if we hit an object. Return true and the position if we hit one Return the hit pos or the original dest pos

    {
        bool result = false;
        float maxDist = (pPos2 - pPos1).magnitude();
        // valid map coords should *never ever* produce float overflow, but this would produce NaNs too
        ASSERT(maxDist < std::numeric_limits<float>::max());
        // prevent NaN values which can cause BIH intersection to enter infinite loop
        if (maxDist < 1e-10f)
        {
            pResultHitPos = pPos2;
            return false;
        }
        Vector3 dir = (pPos2 - pPos1) / maxDist;            // direction with length of 1
        G3D::Ray ray(pPos1, dir);
        float dist = maxDist;
        if (GetIntersectionTime(ray, dist, false, ModelIgnoreFlags::Nothing))
        {
            pResultHitPos = pPos1 + dir * dist;
            if (pModifyDist < 0)
            {
                if ((pResultHitPos - pPos1).magnitude() > -pModifyDist)
                {
                    pResultHitPos = pResultHitPos + dir * pModifyDist;
                }
                else
                {
                    pResultHitPos = pPos1;
                }
            }
            else
            {
                pResultHitPos = pResultHitPos + dir * pModifyDist;
            }
            result = true;
        }
        else
        {
            pResultHitPos = pPos2;
            result = false;
        }
        return result;
    }

References ASSERT, GetIntersectionTime(), and VMAP::Nothing.

getTileFileName()

std::string VMAP::StaticMapTree::getTileFileName ( uint32  mapID, uint32  tileX, uint32  tileY  )

static

    {
        std::stringstream tilefilename;
        tilefilename.fill('0');
        tilefilename << std::setw(3) << mapID << '_';
        //tilefilename << std::setw(2) << tileX << '_' << std::setw(2) << tileY << ".vmtile";
        tilefilename << std::setw(2) << tileY << '_' << std::setw(2) << tileX << ".vmtile";
        return tilefilename.str();
    }

Referenced by CanLoadMap(), LoadMapTile(), and UnloadMapTile().

InitMap()

bool VMAP::StaticMapTree::InitMap	(	const std::string &	fname,
		VMapMgr2 *	vm
	)

    {
        //VMAP_DEBUG_LOG(LOG_FILTER_MAPS, "StaticMapTree::InitMap() : initializing StaticMapTree '{}'", fname);
        bool success = false;
        std::string fullname = iBasePath + fname;
        FILE* rf = fopen(fullname.c_str(), "rb");
        if (!rf)
        {
            return false;
        }
 
        char chunk[8];
        char tiled = '\0';
 
        if (readChunk(rf, chunk, VMAP_MAGIC, 8) && fread(&tiled, sizeof(char), 1, rf) == 1 &&
                readChunk(rf, chunk, "NODE", 4) && iTree.readFromFile(rf))
        {
            iNTreeValues = iTree.primCount();
            iTreeValues = new ModelInstance[iNTreeValues];
            success = readChunk(rf, chunk, "GOBJ", 4);
        }
 
        iIsTiled = bool(tiled);
 
        // global model spawns
        // only non-tiled maps have them, and if so exactly one (so far at least...)
        ModelSpawn spawn;
#ifdef VMAP_DEBUG
        //LOG_DEBUG(LOG_FILTER_MAPS, "StaticMapTree::InitMap() : map isTiled: {}", static_cast<uint32>(iIsTiled));
#endif
        if (!iIsTiled && ModelSpawn::readFromFile(rf, spawn))
        {
            WorldModel* model = vm->acquireModelInstance(iBasePath, spawn.name, spawn.flags);
            //VMAP_DEBUG_LOG(LOG_FILTER_MAPS, "StaticMapTree::InitMap() : loading {}", spawn.name);
            if (model)
            {
                // assume that global model always is the first and only tree value (could be improved...)
                iTreeValues[0] = ModelInstance(spawn, model);
                iLoadedSpawns[0] = 1;
            }
            else
            {
                success = false;
                //VMAP_ERROR_LOG(LOG_FILTER_GENERAL, "StaticMapTree::InitMap() : could not acquire WorldModel pointer for '{}'", spawn.name);
            }
        }
 
        fclose(rf);
        return success;
    }

References VMAP::VMapMgr2::acquireModelInstance(), VMAP::ModelSpawn::flags, iBasePath, iIsTiled, iLoadedSpawns, iNTreeValues, iTree, iTreeValues, VMAP::ModelSpawn::name, BIH::primCount(), VMAP::readChunk(), BIH::readFromFile(), VMAP::ModelSpawn::readFromFile(), and VMAP::VMAP_MAGIC.

Referenced by VMAP::VMapMgr2::_loadMap().

isInLineOfSight()

bool VMAP::StaticMapTree::isInLineOfSight	(	const G3D::Vector3 &	pos1,
		const G3D::Vector3 &	pos2,
		ModelIgnoreFlags	ignoreFlags
	)		const

    {
        float maxDist = (pos2 - pos1).magnitude();
        // return false if distance is over max float, in case of cheater teleporting to the end of the universe
        if (maxDist == std::numeric_limits<float>::max() || !std::isfinite(maxDist))
        {
            return false;
        }
 
        // valid map coords should *never ever* produce float overflow, but this would produce NaNs too
        ASSERT(maxDist < std::numeric_limits<float>::max());
        // prevent NaN values which can cause BIH intersection to enter infinite loop
        if (maxDist < 1e-10f)
        {
            return true;
        }
        // direction with length of 1
        G3D::Ray ray = G3D::Ray::fromOriginAndDirection(pos1, (pos2 - pos1) / maxDist);
 
        return !GetIntersectionTime(ray, maxDist, true, ignoreFlags);
    }

References ASSERT, and GetIntersectionTime().

isTiled()

bool VMAP::StaticMapTree::isTiled ( ) const

inline

{ return iIsTiled; }

References iIsTiled.

LoadMapTile()

bool VMAP::StaticMapTree::LoadMapTile	(	uint32	tileX,
		uint32	tileY,
		VMapMgr2 *	vm
	)

    {
        if (!iIsTiled)
        {
            // currently, core creates grids for all maps, whether it has terrain tiles or not
            // so we need "fake" tile loads to know when we can unload map geometry
            iLoadedTiles[packTileID(tileX, tileY)] = false;
            return true;
        }
        if (!iTreeValues)
        {
            LOG_ERROR("maps", "StaticMapTree::LoadMapTile() : tree has not been initialized [{}, {}]", tileX, tileY);
            return false;
        }
        bool result = true;
 
        std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
        FILE* tf = fopen(tilefile.c_str(), "rb");
        if (tf)
        {
            char chunk[8];
 
            if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
            {
                result = false;
            }
            uint32 numSpawns = 0;
            if (result && fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
            {
                result = false;
            }
            for (uint32 i = 0; i < numSpawns && result; ++i)
            {
                // read model spawns
                ModelSpawn spawn;
                result = ModelSpawn::readFromFile(tf, spawn);
                if (result)
                {
                    // acquire model instance
                    WorldModel* model = vm->acquireModelInstance(iBasePath, spawn.name, spawn.flags);
                    if (!model)
                    {
                        LOG_ERROR("maps", "StaticMapTree::LoadMapTile() : could not acquire WorldModel pointer [{}, {}]", tileX, tileY);
                    }
 
                    // update tree
                    uint32 referencedVal;
 
                    if (fread(&referencedVal, sizeof(uint32), 1, tf) == 1)
                    {
                        if (!iLoadedSpawns.count(referencedVal))
                        {
#if defined(VMAP_DEBUG)
                            if (referencedVal > iNTreeValues)
                            {
                                LOG_DEBUG("maps", "StaticMapTree::LoadMapTile() : invalid tree element ({}/{})", referencedVal, iNTreeValues);
                                continue;
                            }
#endif
                            iTreeValues[referencedVal] = ModelInstance(spawn, model);
                            iLoadedSpawns[referencedVal] = 1;
                        }
                        else
                        {
                            ++iLoadedSpawns[referencedVal];
#if defined(VMAP_DEBUG)
                            if (iTreeValues[referencedVal].ID != spawn.ID)
                            {
                                LOG_DEBUG("maps", "StaticMapTree::LoadMapTile() : trying to load wrong spawn in node");
                            }
                            else if (iTreeValues[referencedVal].name != spawn.name)
                            {
                                LOG_DEBUG("maps", "StaticMapTree::LoadMapTile() : name collision on GUID={}", spawn.ID);
                            }
#endif
                        }
                    }
                    else
                    {
                        result = false;
                    }
                }
            }
            iLoadedTiles[packTileID(tileX, tileY)] = true;
            fclose(tf);
        }
        else
        {
            iLoadedTiles[packTileID(tileX, tileY)] = false;
        }
 
        METRIC_EVENT("map_events", "LoadMapTile",
            "Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
 
        return result;
    }

References VMAP::VMapMgr2::acquireModelInstance(), VMAP::ModelSpawn::flags, getTileFileName(), iBasePath, VMAP::ModelSpawn::ID, iIsTiled, iLoadedSpawns, iLoadedTiles, iMapID, iNTreeValues, iTreeValues, LOG_DEBUG, LOG_ERROR, METRIC_EVENT, VMAP::ModelSpawn::name, packTileID(), VMAP::readChunk(), VMAP::ModelSpawn::readFromFile(), and VMAP::VMAP_MAGIC.

Referenced by VMAP::VMapMgr2::_loadMap().

numLoadedTiles()

uint32 VMAP::StaticMapTree::numLoadedTiles ( ) const

inline

{ return iLoadedTiles.size(); }

References iLoadedTiles.

packTileID()

static uint32 VMAP::StaticMapTree::packTileID ( uint32  tileX, uint32  tileY  )

inlinestatic

{ return tileX << 16 | tileY; }

Referenced by VMAP::TileAssembler::convertWorld2(), MMAP::MapBuilder::discoverTiles(), LoadMapTile(), VMAP::TileAssembler::readMapSpawns(), and UnloadMapTile().

UnloadMap()

void VMAP::StaticMapTree::UnloadMap

(

VMapMgr2 *

vm

)

    {
        for (loadedSpawnMap::iterator i = iLoadedSpawns.begin(); i != iLoadedSpawns.end(); ++i)
        {
            iTreeValues[i->first].setUnloaded();
            for (uint32 refCount = 0; refCount < i->second; ++refCount)
            {
                vm->releaseModelInstance(iTreeValues[i->first].name);
            }
        }
        iLoadedSpawns.clear();
        iLoadedTiles.clear();
    }

References iLoadedSpawns, iLoadedTiles, iTreeValues, VMAP::ModelSpawn::name, VMAP::VMapMgr2::releaseModelInstance(), and VMAP::ModelInstance::setUnloaded().

UnloadMapTile()

void VMAP::StaticMapTree::UnloadMapTile	(	uint32	tileX,
		uint32	tileY,
		VMapMgr2 *	vm
	)

    {
        uint32 tileID = packTileID(tileX, tileY);
        loadedTileMap::iterator tile = iLoadedTiles.find(tileID);
        if (tile == iLoadedTiles.end())
        {
            LOG_ERROR("maps", "StaticMapTree::UnloadMapTile() : trying to unload non-loaded tile - Map:{} X:{} Y:{}", iMapID, tileX, tileY);
            return;
        }
        if (tile->second) // file associated with tile
        {
            std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
            FILE* tf = fopen(tilefile.c_str(), "rb");
            if (tf)
            {
                bool result = true;
                char chunk[8];
                if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
                {
                    result = false;
                }
                uint32 numSpawns;
                if (fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
                {
                    result = false;
                }
                for (uint32 i = 0; i < numSpawns && result; ++i)
                {
                    // read model spawns
                    ModelSpawn spawn;
                    result = ModelSpawn::readFromFile(tf, spawn);
                    if (result)
                    {
                        // release model instance
                        vm->releaseModelInstance(spawn.name);
 
                        // update tree
                        uint32 referencedNode;
 
                        if (fread(&referencedNode, sizeof(uint32), 1, tf) != 1)
                        {
                            result = false;
                        }
                        else
                        {
                            if (!iLoadedSpawns.count(referencedNode))
                            {
                                LOG_ERROR("maps", "StaticMapTree::UnloadMapTile() : trying to unload non-referenced model '{}' (ID:{})", spawn.name, spawn.ID);
                            }
                            else if (--iLoadedSpawns[referencedNode] == 0)
                            {
                                iTreeValues[referencedNode].setUnloaded();
                                iLoadedSpawns.erase(referencedNode);
                            }
                        }
                    }
                }
                fclose(tf);
            }
        }
        iLoadedTiles.erase(tile);
 
        METRIC_EVENT("map_events", "UnloadMapTile",
            "Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
    }

References getTileFileName(), iBasePath, VMAP::ModelSpawn::ID, iLoadedSpawns, iLoadedTiles, iMapID, iTreeValues, LOG_ERROR, METRIC_EVENT, VMAP::ModelSpawn::name, packTileID(), VMAP::readChunk(), VMAP::ModelSpawn::readFromFile(), VMAP::VMapMgr2::releaseModelInstance(), VMAP::ModelInstance::setUnloaded(), and VMAP::VMAP_MAGIC.

unpackTileID()

static void VMAP::StaticMapTree::unpackTileID ( uint32  ID, uint32 &  tileX, uint32 &  tileY  )

inlinestatic

{ tileX = ID >> 16; tileY = ID & 0xFF; }

Referenced by MMAP::MapBuilder::buildMap(), MMAP::MapBuilder::buildNavMesh(), and VMAP::TileAssembler::convertWorld2().

Member Data Documentation

iBasePath

std::string VMAP::StaticMapTree::iBasePath

private

Referenced by InitMap(), LoadMapTile(), StaticMapTree(), and UnloadMapTile().

iIsTiled

bool VMAP::StaticMapTree::iIsTiled

private

Referenced by InitMap(), isTiled(), and LoadMapTile().

iLoadedSpawns

loadedSpawnMap VMAP::StaticMapTree::iLoadedSpawns

private

Referenced by InitMap(), LoadMapTile(), UnloadMap(), and UnloadMapTile().

iLoadedTiles

loadedTileMap VMAP::StaticMapTree::iLoadedTiles

private

Referenced by LoadMapTile(), numLoadedTiles(), UnloadMap(), and UnloadMapTile().

iMapID

uint32 VMAP::StaticMapTree::iMapID

private

Referenced by LoadMapTile(), and UnloadMapTile().

iNTreeValues

uint32 VMAP::StaticMapTree::iNTreeValues

private

Referenced by GetModelInstances(), InitMap(), and LoadMapTile().

iTree

BIH VMAP::StaticMapTree::iTree

private

Referenced by GetAreaInfo(), GetIntersectionTime(), GetLocationInfo(), and InitMap().

iTreeValues

ModelInstance* VMAP::StaticMapTree::iTreeValues

private

Referenced by GetAreaInfo(), GetIntersectionTime(), GetLocationInfo(), GetModelInstances(), InitMap(), LoadMapTile(), UnloadMap(), UnloadMapTile(), and ~StaticMapTree().