#include <VMapManager2.h>

Public Types
typedef uint32(*	GetLiquidFlagsFn )(uint32 liquidType)

typedef bool(*	IsVMAPDisabledForFn )(uint32 entry, uint8 flags)

Public Member Functions
G3D::Vector3	convertPositionToInternalRep (float x, float y, float z) const

	VMapManager2 ()

	~VMapManager2 (void)

void	InitializeThreadUnsafe (std::unordered_map< uint32, std::vector< uint32 >> const &mapData)

int	loadMap (const char *pBasePath, unsigned int mapId, int x, int y) override

void	unloadMap (unsigned int mapId, int x, int y) override

void	unloadMap (unsigned int mapId) override

bool	isInLineOfSight (unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2) override

bool	getObjectHitPos (unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2, float &rx, float &ry, float &rz, float modifyDist) override

float	getHeight (unsigned int mapId, float x, float y, float z, float maxSearchDist) override

bool	processCommand (char *) override

bool	getAreaInfo (unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const override

bool	GetLiquidLevel (uint32 pMapId, float x, float y, float z, uint8 reqLiquidType, float &level, float &floor, uint32 &type) const override

WorldModel *	acquireModelInstance (const std::string &basepath, const std::string &filename)

void	releaseModelInstance (const std::string &filename)

virtual std::string	getDirFileName (unsigned int mapId, int, int) const override

virtual bool	existsMap (const char *basePath, unsigned int mapId, int x, int y) override

void	getInstanceMapTree (InstanceTreeMap &instanceMapTree)

Public Member Functions inherited from VMAP::IVMapManager
	IVMapManager ()

virtual	~IVMapManager (void)

void	setEnableLineOfSightCalc (bool pVal)

void	setEnableHeightCalc (bool pVal)

bool	isLineOfSightCalcEnabled () const

bool	isHeightCalcEnabled () const

bool	isMapLoadingEnabled () const

Static Public Member Functions
static std::string	getMapFileName (unsigned int mapId)

Public Attributes
GetLiquidFlagsFn	GetLiquidFlagsPtr

IsVMAPDisabledForFn	IsVMAPDisabledForPtr

Protected Member Functions
bool	_loadMap (uint32 mapId, const std::string &basePath, uint32 tileX, uint32 tileY)

InstanceTreeMap::const_iterator	GetMapTree (uint32 mapId) const

Static Protected Member Functions
static uint32	GetLiquidFlagsDummy (uint32)

static bool	IsVMAPDisabledForDummy (uint32, uint8)

Protected Attributes
ModelFileMap	iLoadedModelFiles

InstanceTreeMap	iInstanceMapTrees

bool	thread_safe_environment

std::mutex	LoadedModelFilesLock

Member Typedef Documentation

typedef uint32(* VMAP::VMapManager2::GetLiquidFlagsFn)(uint32 liquidType)

typedef bool(* VMAP::VMapManager2::IsVMAPDisabledForFn)(uint32 entry, uint8 flags)

Constructor & Destructor Documentation

VMAP::VMapManager2::VMapManager2 ( )

  {
  GetLiquidFlagsPtr = &GetLiquidFlagsDummy;
  IsVMAPDisabledForPtr = &IsVMAPDisabledForDummy;
  thread_safe_environment = true;
  }

Here is the call graph for this function:

VMAP::VMapManager2::~VMapManager2 ( void )

  {
  for (InstanceTreeMap::iterator i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
  {
  delete i->second;
  }
  for (ModelFileMap::iterator i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
  {
  delete i->second.getModel();
  }
  }

Member Function Documentation

bool VMAP::VMapManager2::_loadMap	(	uint32	mapId,
		const std::string &	basePath,
		uint32	tileX,
		uint32	tileY
	)

protected

  {
  InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
  if (instanceTree == iInstanceMapTrees.end())
  {
  if (thread_safe_environment)
  instanceTree = iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId, nullptr)).first;
  else
  ASSERT(false, "Invalid mapId %u tile [%u, %u] passed to VMapManager2 after startup in thread unsafe environment",
  mapId, tileX, tileY);
  }
 
  if (!instanceTree->second)
  {
  std::string mapFileName = getMapFileName(mapId);
  StaticMapTree* newTree = new StaticMapTree(mapId, basePath);
  if (!newTree->InitMap(mapFileName, this))
  {
  delete newTree;
  return false;
  }
  instanceTree->second = newTree;
  }
 
  return instanceTree->second->LoadMapTile(tileX, tileY, this);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

WorldModel * VMAP::VMapManager2::acquireModelInstance	(	const std::string &	basepath,
		const std::string &	filename
	)

Critical section, thread safe access to iLoadedModelFiles

  {
  std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
 
  ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
  if (model == iLoadedModelFiles.end())
  {
  WorldModel* worldmodel = new WorldModel();
  if (!worldmodel->readFile(basepath + filename + ".vmo"))
  {
  VMAP_ERROR_LOG("misc", "VMapManager2: could not load '%s%s.vmo'", basepath.c_str(), filename.c_str());
  delete worldmodel;
  return NULL;
  }
  VMAP_DEBUG_LOG("maps", "VMapManager2: loading file '%s%s'", basepath.c_str(), filename.c_str());
  model = iLoadedModelFiles.insert(std::pair<std::string, ManagedModel>(filename, ManagedModel())).first;
  model->second.setModel(worldmodel);
  }
  model->second.incRefCount();
  return model->second.getModel();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 VMAP::VMapManager2::convertPositionToInternalRep	(	float	x,
		float	y,
		float	z
	)		const

  {
  Vector3 pos;
  const float mid = 0.5f * 64.0f * 533.33333333f;
  pos.x = mid - x;
  pos.y = mid - y;
  pos.z = z;
 
  return pos;
  }

Here is the caller graph for this function:

bool VMAP::VMapManager2::existsMap	(	const char *	basePath,
		unsigned int	mapId,
		int	x,
		int	y
	)

overridevirtual

Implements VMAP::IVMapManager.

  {
  return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y);
  }

Here is the call graph for this function:

bool VMAP::VMapManager2::getAreaInfo	(	unsigned int	pMapId,
		float	x,
		float	y,
		float &	z,
		uint32 &	flags,
		int32 &	adtId,
		int32 &	rootId,
		int32 &	groupId
	)		const

overridevirtual

Query world model area info.

Parameters

z	gets adjusted to the ground height for which this are info is valid

Implements VMAP::IVMapManager.

  {
  if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_AREAFLAG))
  {
  InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
  if (instanceTree != iInstanceMapTrees.end())
  {
  Vector3 pos = convertPositionToInternalRep(x, y, z);
  bool result = instanceTree->second->getAreaInfo(pos, flags, adtId, rootId, groupId);
  // z is not touched by convertPositionToInternalRep(), so just copy
  z = pos.z;
  return result;
  }
  }
 
  return false;
  }

Here is the call graph for this function:

virtual std::string VMAP::VMapManager2::getDirFileName	(	unsigned int	mapId,
		int	,
		int
	)		const

inlineoverridevirtual

Implements VMAP::IVMapManager.

  {
  return getMapFileName(mapId);
  }

float VMAP::VMapManager2::getHeight	(	unsigned int	mapId,
		float	x,
		float	y,
		float	z,
		float	maxSearchDist
	)

overridevirtual

get height or INVALID_HEIGHT if no height available

Implements VMAP::IVMapManager.

  {
  if (isHeightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_HEIGHT))
  {
  InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
  if (instanceTree != iInstanceMapTrees.end())
  {
  Vector3 pos = convertPositionToInternalRep(x, y, z);
  float height = instanceTree->second->getHeight(pos, maxSearchDist);
  if (!(height < G3D::finf()))
  return height = VMAP_INVALID_HEIGHT_VALUE; // No height
 
  return height;
  }
  }
 
  return VMAP_INVALID_HEIGHT_VALUE;
  }

Here is the call graph for this function:

void VMAP::VMapManager2::getInstanceMapTree ( InstanceTreeMap & instanceMapTree )

  {
  instanceMapTree = iInstanceMapTrees;
  }

static uint32 VMAP::VMapManager2::GetLiquidFlagsDummy ( uint32 )

inlinestaticprotected

91 { return 0; }

Here is the caller graph for this function:

bool VMAP::VMapManager2::GetLiquidLevel	(	uint32	pMapId,
		float	x,
		float	y,
		float	z,
		uint8	reqLiquidType,
		float &	level,
		float &	floor,
		uint32 &	type
	)		const

overridevirtual

Implements VMAP::IVMapManager.

  {
  if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LIQUIDSTATUS))
  {
  InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
  if (instanceTree != iInstanceMapTrees.end())
  {
  LocationInfo info;
  Vector3 pos = convertPositionToInternalRep(x, y, z);
  if (instanceTree->second->GetLocationInfo(pos, info))
  {
  floor = info.ground_Z;
  ASSERT(floor < std::numeric_limits<float>::max());
  ASSERT(info.hitModel);
  type = info.hitModel->GetLiquidType(); // entry from LiquidType.dbc
  if (reqLiquidType && !(GetLiquidFlagsPtr(type) & reqLiquidType))
  return false;
  ASSERT(info.hitInstance);
  if (info.hitInstance->GetLiquidLevel(pos, info, level))
  return true;
  }
  }
  }
 
  return false;
  }

Here is the call graph for this function:

std::string VMAP::VMapManager2::getMapFileName ( unsigned int mapId )

static

  {
  std::stringstream fname;
  fname.width(4);
  fname << std::setfill('0') << mapId << std::string(MAP_FILENAME_EXTENSION2);
 
  return fname.str();
  }

Here is the caller graph for this function:

InstanceTreeMap::const_iterator VMAP::VMapManager2::GetMapTree ( uint32 mapId ) const

protected

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

Here is the caller graph for this function:

bool VMAP::VMapManager2::getObjectHitPos	(	unsigned int	mapId,
		float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2,
		float &	rx,
		float &	ry,
		float &	rz,
		float	modifyDist
	)

overridevirtual

fill the hit pos and return true, if an object was hit

get the hit position and return true if we hit something otherwise the result pos will be the dest pos

Implements VMAP::IVMapManager.

  {
  if (isLineOfSightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
  {
  InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
  if (instanceTree != iInstanceMapTrees.end())
  {
  Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
  Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
  Vector3 resultPos;
  bool result = instanceTree->second->getObjectHitPos(pos1, pos2, resultPos, modifyDist);
  resultPos = convertPositionToInternalRep(resultPos.x, resultPos.y, resultPos.z);
  rx = resultPos.x;
  ry = resultPos.y;
  rz = resultPos.z;
  return result;
  }
  }
 
  rx = x2;
  ry = y2;
  rz = z2;
 
  return false;
  }

Here is the call graph for this function:

void VMAP::VMapManager2::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 VMapManager2 lifetime
  for (auto const& p : mapData)
  iInstanceMapTrees.insert(InstanceTreeMap::value_type(p.first, nullptr));
 
  thread_safe_environment = false;
  }

bool VMAP::VMapManager2::isInLineOfSight	(	unsigned int	mapId,
		float	x1,
		float	y1,
		float	z1,
		float	x2,
		float	y2,
		float	z2
	)

overridevirtual

Implements VMAP::IVMapManager.

  {
  if (!isLineOfSightCalcEnabled() || IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
  return true;
 
  InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
  if (instanceTree != iInstanceMapTrees.end())
  {
  Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
  Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
  if (pos1 != pos2)
  {
  return instanceTree->second->isInLineOfSight(pos1, pos2);
  }
  }
 
  return true;
  }

Here is the call graph for this function:

static bool VMAP::VMapManager2::IsVMAPDisabledForDummy	(	uint32	,
		uint8
	)

inlinestaticprotected

92 { return false; }

Here is the caller graph for this function:

int VMAP::VMapManager2::loadMap	(	const char *	pBasePath,
		unsigned int	mapId,
		int	x,
		int	y
	)

overridevirtual

Implements VMAP::IVMapManager.

  {
  int result = VMAP_LOAD_RESULT_IGNORED;
  if (isMapLoadingEnabled())
  {
  if (_loadMap(mapId, basePath, x, y))
  result = VMAP_LOAD_RESULT_OK;
  else
  result = VMAP_LOAD_RESULT_ERROR;
  }
 
  return result;
  }

Here is the call graph for this function:

bool VMAP::VMapManager2::processCommand ( char * pCommand )

inlineoverridevirtual

send debug commands

Implements VMAP::IVMapManager.

117 { return false; } // for debug and extensions

void VMAP::VMapManager2::releaseModelInstance ( const std::string & filename )

Critical section, thread safe access to iLoadedModelFiles

  {
  std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
 
  ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
  if (model == iLoadedModelFiles.end())
  {
  VMAP_ERROR_LOG("misc", "VMapManager2: trying to unload non-loaded file '%s'", filename.c_str());
  return;
  }
  if (model->second.decRefCount() == 0)
  {
  VMAP_DEBUG_LOG("maps", "VMapManager2: unloading file '%s'", filename.c_str());
  delete model->second.getModel();
  iLoadedModelFiles.erase(model);
  }
  }

Here is the caller graph for this function:

void VMAP::VMapManager2::unloadMap	(	unsigned int	mapId,
		int	x,
		int	y
	)

overridevirtual

Implements VMAP::IVMapManager.

  {
  InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
  if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
  {
  instanceTree->second->UnloadMapTile(x, y, this);
  if (instanceTree->second->numLoadedTiles() == 0)
  {
  delete instanceTree->second;
  instanceTree->second = nullptr;
  }
  }
  }

void VMAP::VMapManager2::unloadMap ( unsigned int mapId )

overridevirtual

Implements VMAP::IVMapManager.

  {
  InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
  if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
  {
  instanceTree->second->UnloadMap(this);
  if (instanceTree->second->numLoadedTiles() == 0)
  {
  delete instanceTree->second;
  instanceTree->second = nullptr;
  }
  }
  }

Member Data Documentation

GetLiquidFlagsFn VMAP::VMapManager2::GetLiquidFlagsPtr

InstanceTreeMap VMAP::VMapManager2::iInstanceMapTrees

protected

ModelFileMap VMAP::VMapManager2::iLoadedModelFiles

protected

IsVMAPDisabledForFn VMAP::VMapManager2::IsVMAPDisabledForPtr

std::mutex VMAP::VMapManager2::LoadedModelFilesLock

protected

bool VMAP::VMapManager2::thread_safe_environment

protected

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

src/common/Collision/Management/VMapManager2.h
src/common/Collision/Management/VMapManager2.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation