VMAP::VMapMgr2 Class Reference

#include "VMapMgr2.h"

Inheritance diagram for VMAP::VMapMgr2:

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
	VMapMgr2 ()
	~VMapMgr2 () override
void	InitializeThreadUnsafe (const std::vector< uint32 > &mapIds)
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, ModelIgnoreFlags ignoreFlags) 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	GetAreaAndLiquidData (uint32 mapId, float x, float y, float z, Optional< uint8 > reqLiquidType, AreaAndLiquidData &data) const override
WorldModel *	acquireModelInstance (const std::string &basepath, const std::string &filename, uint32 flags)
void	releaseModelInstance (const std::string &filename)
std::string	getDirFileName (unsigned int mapId, int, int) const override
LoadResult	existsMap (const char *basePath, unsigned int mapId, int x, int y) override
void	GetInstanceMapTree (InstanceTreeMap &instanceMapTree)
Public Member Functions inherited from VMAP::IVMapMgr
	IVMapMgr ()
virtual	~IVMapMgr ()=default
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

Detailed Description

Member Typedef Documentation

GetLiquidFlagsFn

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

IsVMAPDisabledForFn

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

Constructor & Destructor Documentation

VMapMgr2()

VMAP::VMapMgr2::VMapMgr2

(

)

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

References GetLiquidFlagsDummy(), GetLiquidFlagsPtr, IsVMAPDisabledForDummy(), IsVMAPDisabledForPtr, and thread_safe_environment.

~VMapMgr2()

VMAP::VMapMgr2::~VMapMgr2 ( )

override

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

References iInstanceMapTrees, and iLoadedModelFiles.

Member Function Documentation

_loadMap()

bool VMAP::VMapMgr2::_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
                ABORT("Invalid mapId {} tile [{}, {}] passed to VMapMgr2 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);
    }

References ABORT, getMapFileName(), iInstanceMapTrees, VMAP::StaticMapTree::InitMap(), VMAP::StaticMapTree::LoadMapTile(), and thread_safe_environment.

Referenced by loadMap().

acquireModelInstance()

WorldModel * VMAP::VMapMgr2::acquireModelInstance	(	const std::string &	basepath,
		const std::string &	filename,
		uint32	flags
	)

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"))
            {
                LOG_ERROR("maps", "VMapMgr2: could not load '{}{}.vmo'", basepath, filename);
                delete worldmodel;
                return nullptr;
            }
            LOG_DEBUG("maps", "VMapMgr2: loading file '{}{}'", basepath, filename);
 
            worldmodel->Flags = flags;
 
            model = iLoadedModelFiles.insert(std::pair<std::string, ManagedModel>(filename, ManagedModel())).first;
            model->second.setModel(worldmodel);
        }
 
        return model->second.getModel();
    }

References VMAP::WorldModel::Flags, iLoadedModelFiles, LoadedModelFilesLock, LOG_DEBUG, LOG_ERROR, and VMAP::WorldModel::readFile().

Referenced by GameObjectModel::initialize(), VMAP::StaticMapTree::InitMap(), and VMAP::StaticMapTree::LoadMapTile().

convertPositionToInternalRep()

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

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

References MAX_NUMBER_OF_GRIDS, and SIZE_OF_GRIDS.

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

existsMap()

LoadResult VMAP::VMapMgr2::existsMap ( const char *  basePath, unsigned int  mapId, int  x, int  y  )

overridevirtual

Implements VMAP::IVMapMgr.

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

References VMAP::StaticMapTree::CanLoadMap().

GetAreaAndLiquidData()

bool VMAP::VMapMgr2::GetAreaAndLiquidData ( uint32  mapId, float  x, float  y, float  z, Optional< uint8 >  reqLiquidType, AreaAndLiquidData &  data  ) const

overridevirtual

Query world model area info.

Parameters

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

Implements VMAP::IVMapMgr.

    {
        InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
        if (instanceTree != iInstanceMapTrees.end())
        {
            LocationInfo info;
            Vector3      pos = convertPositionToInternalRep(x, y, z);
            if (instanceTree->second->GetLocationInfo(pos, info))
            {
                data.floorZ       = info.ground_Z;
                if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LIQUIDSTATUS))
                {
                    uint32 liquidType = info.hitModel->GetLiquidType(); // entry from LiquidType.dbc
                    float liquidLevel;
                    if (!reqLiquidType || (GetLiquidFlagsPtr(liquidType) & *reqLiquidType))
                        if (info.hitInstance->GetLiquidLevel(pos, info, liquidLevel))
                            data.liquidInfo.emplace(liquidType, liquidLevel);
                }
 
                if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_AREAFLAG))
                    data.areaInfo.emplace(info.hitModel->GetWmoID(), info.hitInstance->adtId, info.rootId, info.hitModel->GetMogpFlags(), info.hitInstance->ID);
                return true;
            }
        }
 
        return false;
    }

References VMAP::ModelSpawn::adtId, VMAP::AreaAndLiquidData::areaInfo, convertPositionToInternalRep(), VMAP::AreaAndLiquidData::floorZ, GetLiquidFlagsPtr, VMAP::ModelInstance::GetLiquidLevel(), VMAP::GroupModel::GetLiquidType(), GetMapTree(), VMAP::GroupModel::GetMogpFlags(), VMAP::GroupModel::GetWmoID(), VMAP::LocationInfo::ground_Z, VMAP::LocationInfo::hitInstance, VMAP::LocationInfo::hitModel, VMAP::ModelSpawn::ID, iInstanceMapTrees, IsVMAPDisabledForPtr, VMAP::AreaAndLiquidData::liquidInfo, VMAP::LocationInfo::rootId, VMAP::VMAP_DISABLE_AREAFLAG, and VMAP::VMAP_DISABLE_LIQUIDSTATUS.

getDirFileName()

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

inlineoverridevirtual

Implements VMAP::IVMapMgr.

        {
            return getMapFileName(mapId);
        }

References getMapFileName().

getHeight()

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

overridevirtual

get height or INVALID_HEIGHT if no height available

Implements VMAP::IVMapMgr.

    {
#if defined(ENABLE_VMAP_CHECKS)
        if (isHeightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_HEIGHT))
#endif
        {
            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;
    }

References convertPositionToInternalRep(), GetMapTree(), iInstanceMapTrees, VMAP::IVMapMgr::isHeightCalcEnabled(), IsVMAPDisabledForPtr, VMAP::VMAP_DISABLE_HEIGHT, and VMAP_INVALID_HEIGHT_VALUE.

GetInstanceMapTree()

void VMAP::VMapMgr2::GetInstanceMapTree

(

InstanceTreeMap &

instanceMapTree

)

    {
        instanceMapTree = iInstanceMapTrees;
    }

References iInstanceMapTrees.

GetLiquidFlagsDummy()

static uint32 VMAP::VMapMgr2::GetLiquidFlagsDummy ( uint32  )

inlinestaticprotected

{ return 0; }

Referenced by VMapMgr2().

getMapFileName()

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

static

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

References MAP_FILENAME_EXTENSION2.

Referenced by _loadMap(), VMAP::StaticMapTree::CanLoadMap(), and getDirFileName().

GetMapTree()

InstanceTreeMap::const_iterator VMAP::VMapMgr2::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;
    }

References iInstanceMapTrees.

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

GetObjectHitPos()

bool VMAP::VMapMgr2::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::IVMapMgr.

    {
#if defined(ENABLE_VMAP_CHECKS)
        if (isLineOfSightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
#endif
        {
            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;
    }

References convertPositionToInternalRep(), GetMapTree(), iInstanceMapTrees, VMAP::IVMapMgr::isLineOfSightCalcEnabled(), IsVMAPDisabledForPtr, and VMAP::VMAP_DISABLE_LOS.

Referenced by Map::CheckCollisionAndGetValidCoords(), and Spell::SelectImplicitCasterDestTargets().

InitializeThreadUnsafe()

void VMAP::VMapMgr2::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)
        {
            iInstanceMapTrees.emplace(mapId, nullptr);
        }
 
        thread_safe_environment = false;
    }

References iInstanceMapTrees, and thread_safe_environment.

Referenced by World::SetInitialWorldSettings().

isInLineOfSight()

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

overridevirtual

Implements VMAP::IVMapMgr.

    {
#if defined(ENABLE_VMAP_CHECKS)
        if (!isLineOfSightCalcEnabled() || IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
        {
            return true;
        }
#endif
 
        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, ignoreFlags);
            }
        }
 
        return true;
    }

References convertPositionToInternalRep(), GetMapTree(), iInstanceMapTrees, VMAP::IVMapMgr::isLineOfSightCalcEnabled(), IsVMAPDisabledForPtr, and VMAP::VMAP_DISABLE_LOS.

IsVMAPDisabledForDummy()

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

inlinestaticprotected

{ return false; }

Referenced by VMapMgr2().

loadMap()

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

overridevirtual

Implements VMAP::IVMapMgr.

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

References _loadMap(), VMAP::IVMapMgr::isMapLoadingEnabled(), VMAP::VMAP_LOAD_RESULT_ERROR, VMAP::VMAP_LOAD_RESULT_IGNORED, and VMAP::VMAP_LOAD_RESULT_OK.

Referenced by GridTerrainLoader::LoadVMap().

processCommand()

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

inlineoverridevirtual

send debug commands

Implements VMAP::IVMapMgr.

{ return false; } // for debug and extensions

releaseModelInstance()

void VMAP::VMapMgr2::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())
        {
            LOG_ERROR("maps", "VMapMgr2: trying to unload non-loaded file '{}'", filename);
            return;
        }
        if (model->second.decRefCount() == 0)
        {
            LOG_DEBUG("maps", "VMapMgr2: unloading file '{}'", filename);
            delete model->second.getModel();
            iLoadedModelFiles.erase(model);
        }
    }

References iLoadedModelFiles, LoadedModelFilesLock, LOG_DEBUG, and LOG_ERROR.

Referenced by VMAP::StaticMapTree::UnloadMap(), VMAP::StaticMapTree::UnloadMapTile(), and GameObjectModel::~GameObjectModel().

unloadMap() [1/2]

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

overridevirtual

Implements VMAP::IVMapMgr.

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

References iInstanceMapTrees.

unloadMap() [2/2]

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

overridevirtual

Implements VMAP::IVMapMgr.

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

References iInstanceMapTrees.

Referenced by GridTerrainUnloader::UnloadTerrain().

Member Data Documentation

GetLiquidFlagsPtr

GetLiquidFlagsFn VMAP::VMapMgr2::GetLiquidFlagsPtr

Referenced by GetAreaAndLiquidData(), World::SetInitialWorldSettings(), and VMapMgr2().

iInstanceMapTrees

InstanceTreeMap VMAP::VMapMgr2::iInstanceMapTrees

protected

Referenced by _loadMap(), GetAreaAndLiquidData(), getHeight(), GetInstanceMapTree(), GetMapTree(), GetObjectHitPos(), InitializeThreadUnsafe(), isInLineOfSight(), unloadMap(), unloadMap(), and ~VMapMgr2().

iLoadedModelFiles

ModelFileMap VMAP::VMapMgr2::iLoadedModelFiles

protected

Referenced by acquireModelInstance(), releaseModelInstance(), and ~VMapMgr2().

IsVMAPDisabledForPtr

IsVMAPDisabledForFn VMAP::VMapMgr2::IsVMAPDisabledForPtr

Referenced by GetAreaAndLiquidData(), getHeight(), GetObjectHitPos(), isInLineOfSight(), World::SetInitialWorldSettings(), and VMapMgr2().

LoadedModelFilesLock

std::mutex VMAP::VMapMgr2::LoadedModelFilesLock

protected

Referenced by acquireModelInstance(), and releaseModelInstance().

thread_safe_environment

bool VMAP::VMapMgr2::thread_safe_environment

protected

Referenced by _loadMap(), InitializeThreadUnsafe(), and VMapMgr2().

---

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

• azerothcore-wotlk/src/common/Collision/Management/VMapMgr2.h
• azerothcore-wotlk/src/common/Collision/Management/VMapMgr2.cpp