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. More...
bool	isInLineOfSight (const G3D::Vector3 &pos1, const G3D::Vector3 &pos2) 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, VMapManager2 *vm)
void	UnloadMap (VMapManager2 *vm)
bool	LoadMapTile (uint32 tileX, uint32 tileY, VMapManager2 *vm)
void	UnloadMapTile (uint32 tileX, uint32 tileY, VMapManager2 *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 bool	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 pStopAtFirstHit) const
	StaticMapTree (StaticMapTree const &right)=delete
StaticMapTree &	operator= (StaticMapTree const &right)=delete

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

Member Typedef Documentation

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

private

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

private

Constructor & Destructor Documentation

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

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

VMAP::StaticMapTree::~StaticMapTree

(

)

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

 {
 delete[] iTreeValues;
 }

VMAP::StaticMapTree::StaticMapTree ( StaticMapTree const &  right )

privatedelete

Member Function Documentation

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

static

Todo:

check magic number when implemented...

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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))
 {
 height = pPos.z - maxDist;
 }
 return(height);
 }

Here is the call graph for this function:

bool VMAP::StaticMapTree::getIntersectionTime ( const G3D::Ray &  pRay, float &  pMaxDist, bool  pStopAtFirstHit  ) 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);
 iTree.intersectRay(pRay, intersectionCallBack, distance, pStopAtFirstHit);
 if (intersectionCallBack.didHit())
 pMaxDist = distance;
 return intersectionCallBack.didHit();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

 {
 models = iTreeValues;
 count = iNTreeValues;
 }

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

Here is the call graph for this function:

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

static

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

Here is the caller graph for this function:

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

 {
 VMAP_DEBUG_LOG("maps", "StaticMapTree::InitMap() : initializing StaticMapTree '%s'", fname.c_str());
 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 = tiled != '\0';

 // global model spawns
 // only non-tiled maps have them, and if so exactly one (so far at least...)
 ModelSpawn spawn;
#ifdef VMAP_DEBUG
 TC_LOG_DEBUG("maps", "StaticMapTree::InitMap() : map isTiled: %u", static_cast<uint32>(iIsTiled));
#endif
 if (!iIsTiled && ModelSpawn::readFromFile(rf, spawn))
 {
 WorldModel* model = vm->acquireModelInstance(iBasePath, spawn.name);
 VMAP_DEBUG_LOG("maps", "StaticMapTree::InitMap() : loading %s", spawn.name.c_str());
 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("misc", "StaticMapTree::InitMap() : could not acquire WorldModel pointer for '%s'", spawn.name.c_str());
 }
 }

 fclose(rf);
 return success;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool VMAP::StaticMapTree::isInLineOfSight	(	const G3D::Vector3 &	pos1,
		const G3D::Vector3 &	pos2
	)		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);
 if (getIntersectionTime(ray, maxDist, true))
 return false;

 return true;
 }

Here is the call graph for this function:

bool VMAP::StaticMapTree::isTiled ( ) const

inline

{ return iIsTiled; }

bool VMAP::StaticMapTree::LoadMapTile	(	uint32	tileX,
		uint32	tileY,
		VMapManager2 *	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)
 {
 VMAP_ERROR_LOG("misc", "StaticMapTree::LoadMapTile() : tree has not been initialized [%u, %u]", 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);
 if (!model)
 VMAP_ERROR_LOG("misc", "StaticMapTree::LoadMapTile() : could not acquire WorldModel pointer [%u, %u]", tileX, tileY);

 // update tree
 uint32 referencedVal;

 if (fread(&referencedVal, sizeof(uint32), 1, tf) == 1)
 {
 if (!iLoadedSpawns.count(referencedVal))
 {
 if (referencedVal > iNTreeValues)
 {
 VMAP_ERROR_LOG("maps", "StaticMapTree::LoadMapTile() : invalid tree element (%u/%u) referenced in tile %s", referencedVal, iNTreeValues, tilefile.c_str());
 continue;
 }

 iTreeValues[referencedVal] = ModelInstance(spawn, model);
 iLoadedSpawns[referencedVal] = 1;
 }
 else
 {
 ++iLoadedSpawns[referencedVal];
#ifdef VMAP_DEBUG
 if (iTreeValues[referencedVal].ID != spawn.ID)
 TC_LOG_DEBUG("maps", "StaticMapTree::LoadMapTile() : trying to load wrong spawn in node");
 else if (iTreeValues[referencedVal].name != spawn.name)
 TC_LOG_DEBUG("maps", "StaticMapTree::LoadMapTile() : name collision on GUID=%u", spawn.ID);
#endif
 }
 }
 else
 result = false;
 }
 }
 iLoadedTiles[packTileID(tileX, tileY)] = true;
 fclose(tf);
 }
 else
 iLoadedTiles[packTileID(tileX, tileY)] = false;
 return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 VMAP::StaticMapTree::numLoadedTiles ( ) const

inline

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

StaticMapTree& VMAP::StaticMapTree::operator= ( StaticMapTree const &  right )

privatedelete

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

inlinestatic

{ return tileX<<16 | tileY; }

Here is the caller graph for this function:

void VMAP::StaticMapTree::UnloadMap

(

VMapManager2 *

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

Here is the call graph for this function:

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

 {
 uint32 tileID = packTileID(tileX, tileY);
 loadedTileMap::iterator tile = iLoadedTiles.find(tileID);
 if (tile == iLoadedTiles.end())
 {
 VMAP_ERROR_LOG("misc", "StaticMapTree::UnloadMapTile() : trying to unload non-loaded tile - Map:%u X:%u Y:%u", 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))
 VMAP_ERROR_LOG("misc", "StaticMapTree::UnloadMapTile() : trying to unload non-referenced model '%s' (ID:%u)", spawn.name.c_str(), spawn.ID);
 else if (--iLoadedSpawns[referencedNode] == 0)
 {
 iTreeValues[referencedNode].setUnloaded();
 iLoadedSpawns.erase(referencedNode);
 }
 }
 }
 }
 fclose(tf);
 }
 }
 iLoadedTiles.erase(tile);
 }

Here is the call graph for this function:

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

inlinestatic

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

Here is the caller graph for this function:

Member Data Documentation

std::string VMAP::StaticMapTree::iBasePath

private

bool VMAP::StaticMapTree::iIsTiled

private

loadedSpawnMap VMAP::StaticMapTree::iLoadedSpawns

private

loadedTileMap VMAP::StaticMapTree::iLoadedTiles

private

uint32 VMAP::StaticMapTree::iMapID

private

uint32 VMAP::StaticMapTree::iNTreeValues

private

BIH VMAP::StaticMapTree::iTree

private

ModelInstance* VMAP::StaticMapTree::iTreeValues

private

---

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

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