Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-15 23:20:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Vmaps: Remove VMapManager2 virtual interface

Browse Source
This commit is contained in:
Shauren
2025-10-25 00:52:55 +02:00
parent 81a1a55851
commit 96b567995a
9 changed files with 191 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/common/Collision/Management/IVMapManager.h
View File

@@ -1,127 +0,0 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _IVMAPMANAGER_H
#define _IVMAPMANAGER_H
#include "Define.h"
#include "ModelIgnoreFlags.h"
#include "Optional.h"
#include <string>
//===========================================================
/**
This is the minimum interface to the VMapMamager.
*/
namespace VMAP
{
enum class LoadResult : uint8
{
Success,
FileNotFound,
VersionMismatch,
ReadFromFileFailed,
DisabledInConfig
};
#define VMAP_INVALID_HEIGHT -100000.0f // for check
#define VMAP_INVALID_HEIGHT_VALUE -200000.0f // real assigned value in unknown height case
struct AreaAndLiquidData
{
struct AreaInfo
{
AreaInfo() = default;
AreaInfo(int32 _groupId, int32 _adtId, int32 _rootId, uint32 _mogpFlags, uint32 _uniqueId)
: groupId(_groupId), adtId(_adtId), rootId(_rootId), mogpFlags(_mogpFlags), uniqueId(_uniqueId) { }
int32 groupId = 0;
int32 adtId = 0;
int32 rootId = 0;
uint32 mogpFlags = 0;
uint32 uniqueId = 0;
};
struct LiquidInfo
{
LiquidInfo() = default;
LiquidInfo(uint32 _type, float _level) : type(_type), level(_level) { }
uint32 type = 0;
float level = 0.0f;
};
float floorZ = VMAP_INVALID_HEIGHT;
Optional<AreaInfo> areaInfo;
Optional<LiquidInfo> liquidInfo;
};
//===========================================================
class TC_COMMON_API IVMapManager
{
private:
bool iEnableLineOfSightCalc;
bool iEnableHeightCalc;
public:
IVMapManager() : iEnableLineOfSightCalc(true), iEnableHeightCalc(true) { }
virtual ~IVMapManager(void) { }
virtual LoadResult loadMap(char const* pBasePath, unsigned int pMapId, int x, int y) = 0;
virtual LoadResult existsMap(char const* pBasePath, unsigned int pMapId, int x, int y) = 0;
virtual void unloadMap(unsigned int pMapId, int x, int y) = 0;
virtual void unloadMap(unsigned int pMapId) = 0;
virtual bool isInLineOfSight(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2, ModelIgnoreFlags ignoreFlags) = 0;
virtual float getHeight(unsigned int pMapId, float x, float y, float z, float maxSearchDist) = 0;
/**
test if we hit an object. return true if we hit one. rx, ry, rz will hold the hit position or the dest position, if no intersection was found
return a position, that is pReduceDist closer to the origin
*/
virtual bool getObjectHitPos(unsigned int pMapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float pModifyDist) = 0;
/**
send debug commands
*/
virtual bool processCommand(char *pCommand)= 0;
/**
Enable/disable LOS calculation
It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
*/
void setEnableLineOfSightCalc(bool pVal) { iEnableLineOfSightCalc = pVal; }
/**
Enable/disable model height calculation
It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
*/
void setEnableHeightCalc(bool pVal) { iEnableHeightCalc = pVal; }
bool isLineOfSightCalcEnabled() const { return(iEnableLineOfSightCalc); }
bool isHeightCalcEnabled() const { return(iEnableHeightCalc); }
bool isMapLoadingEnabled() const { return(iEnableLineOfSightCalc || iEnableHeightCalc ); }
virtual std::string getDirFileName(unsigned int pMapId, int x, int y) const =0;
/**
Query world model area info.
\param z gets adjusted to the ground height for which this are info is valid
*/
virtual bool getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, Optional<uint8> reqLiquidType, AreaAndLiquidData& data) const = 0;
};
}
#endif

2
src/common/Collision/Management/VMapFactory.h
View File

@@ -18,7 +18,7 @@
#ifndef _VMAPFACTORY_H
#define _VMAPFACTORY_H
#include "IVMapManager.h"
#include "Define.h"
/**
This is the access point to the VMapManager.

105
src/common/Collision/Management/VMapManager2.cpp
View File

@@ -23,9 +23,6 @@
#include "VMapDefinitions.h"
#include "WorldModel.h"
#include <G3D/Vector3.h>
#include <string>
using G3D::Vector3;
namespace VMAP
{
@@ -34,6 +31,12 @@ namespace VMAP
public:
explicit ManagedModel(VMapManager2& mgr, std::string const& name) : _mgr(mgr), _name(name) { }
ManagedModel(ManagedModel const&) = delete;
ManagedModel(ManagedModel&&) = delete;
ManagedModel& operator=(ManagedModel const&) = delete;
ManagedModel& operator=(ManagedModel&&) = delete;
~ManagedModel()
{
_mgr.releaseModelInstance(_name);
@@ -52,18 +55,16 @@ namespace VMAP
return memcmp(dest, compare, len) == 0;
}
VMapManager2::VMapManager2()
VMapManager2::VMapManager2() :
iEnableLineOfSightCalc(true),
iEnableHeightCalc(true),
thread_safe_environment(true),
GetLiquidFlagsPtr([](uint32 /*liquidTypeId*/) { return 0u; }),
IsVMAPDisabledForPtr([](uint32 /*mapId*/, uint8 /*disableFlags*/) { return false; })
{
GetLiquidFlagsPtr = &GetLiquidFlagsDummy;
IsVMAPDisabledForPtr = &IsVMAPDisabledForDummy;
thread_safe_environment = true;
}
VMapManager2::~VMapManager2()
{
for (std::pair<uint32 const, StaticMapTree*>& iInstanceMapTree : iInstanceMapTrees)
delete iInstanceMapTree.second;
}
VMapManager2::~VMapManager2() = default;
InstanceTreeMap::const_iterator VMapManager2::GetMapTree(uint32 mapId) const
{
@@ -78,11 +79,11 @@ namespace VMAP
void 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 (std::pair<uint32 const, std::vector<uint32>> const& mapId : mapData)
for (auto const& [mapId, childMapIds] : mapData)
{
iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId.first, nullptr));
for (uint32 childMapId : mapId.second)
iParentMapData[childMapId] = mapId.first;
iInstanceMapTrees[mapId] = nullptr;
for (uint32 childMapId : childMapIds)
iParentMapData[childMapId] = mapId;
}
thread_safe_environment = false;
@@ -95,10 +96,10 @@ namespace VMAP
iParentMapData[mapId] = parentMapId;
}
Vector3 VMapManager2::convertPositionToInternalRep(float x, float y, float z) const
inline static G3D::Vector3 convertPositionToInternalRep(float x, float y, float z)
{
Vector3 pos;
const float mid = 0.5f * 64.0f * 533.33333333f;
G3D::Vector3 pos;
constexpr float mid = 0.5f * 64.0f * 533.33333333f;
pos.x = mid - x;
pos.y = mid - y;
pos.z = z;
@@ -106,13 +107,17 @@ namespace VMAP
return pos;
}
// move to MapTree too?
std::string VMapManager2::getMapFileName(unsigned int mapId)
std::string VMapManager2::getMapFileName(uint32 mapId)
{
return Trinity::StringFormat("{:04}/{:04}.vmtree", mapId, mapId);
}
LoadResult VMapManager2::loadMap(char const* basePath, unsigned int mapId, int x, int y)
std::string VMapManager2::getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY, std::string_view extension)
{
return Trinity::StringFormat("{:04}/{:04}_{:02}_{:02}.{}", mapID, mapID, tileY, tileX, extension);
}
LoadResult VMapManager2::loadMap(std::string const& basePath, uint32 mapId, uint32 x, uint32 y)
{
if (!isMapLoadingEnabled())
return LoadResult::DisabledInConfig;
@@ -130,48 +135,40 @@ namespace VMAP
if (!instanceTree->second)
{
std::string mapFileName = getMapFileName(mapId);
StaticMapTree* newTree = new StaticMapTree(mapId, basePath);
std::unique_ptr<StaticMapTree> newTree = std::make_unique<StaticMapTree>(mapId, basePath);
LoadResult treeInitResult = newTree->InitMap(mapFileName);
if (treeInitResult != LoadResult::Success)
{
delete newTree;
return treeInitResult;
}
instanceTree->second = newTree;
instanceTree->second = std::move(newTree);
}
return instanceTree->second->LoadMapTile(x, y, this);
}
void VMapManager2::unloadMap(unsigned int mapId, int x, int y)
void VMapManager2::unloadMap(uint32 mapId, uint32 x, uint32 y)
{
auto 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 VMapManager2::unloadMap(unsigned int mapId)
void VMapManager2::unloadMap(uint32 mapId)
{
auto instanceTree = iInstanceMapTrees.find(mapId);
if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
{
instanceTree->second->UnloadMap();
if (instanceTree->second->numLoadedTiles() == 0)
{
delete instanceTree->second;
instanceTree->second = nullptr;
}
}
}
bool VMapManager2::isInLineOfSight(unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2, ModelIgnoreFlags ignoreFlags)
bool VMapManager2::isInLineOfSight(uint32 mapId, float x1, float y1, float z1, float x2, float y2, float z2, ModelIgnoreFlags ignoreFlags)
{
if (!isLineOfSightCalcEnabled() || IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
return true;
@@ -179,8 +176,8 @@ namespace VMAP
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
G3D::Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
G3D::Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
if (pos1 != pos2)
return instanceTree->second->isInLineOfSight(pos1, pos2, ignoreFlags);
}
@@ -192,16 +189,16 @@ namespace VMAP
get the hit position and return true if we hit something
otherwise the result pos will be the dest pos
*/
bool 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)
bool VMapManager2::getObjectHitPos(uint32 mapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float &ry, float& rz, float modifyDist)
{
if (isLineOfSightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
{
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
Vector3 resultPos;
G3D::Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
G3D::Vector3 pos2 = convertPositionToInternalRep(x2, y2, z2);
G3D::Vector3 resultPos;
bool result = instanceTree->second->getObjectHitPos(pos1, pos2, resultPos, modifyDist);
resultPos = convertPositionToInternalRep(resultPos.x, resultPos.y, resultPos.z);
rx = resultPos.x;
@@ -222,14 +219,14 @@ namespace VMAP
get height or INVALID_HEIGHT if no height available
*/
float VMapManager2::getHeight(unsigned int mapId, float x, float y, float z, float maxSearchDist)
float VMapManager2::getHeight(uint32 mapId, float x, float y, float z, float maxSearchDist)
{
if (isHeightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_HEIGHT))
{
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos = convertPositionToInternalRep(x, y, z);
G3D::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
@@ -241,13 +238,13 @@ namespace VMAP
return VMAP_INVALID_HEIGHT_VALUE;
}
bool VMapManager2::getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, Optional<uint8> reqLiquidType, AreaAndLiquidData& data) const
bool VMapManager2::getAreaAndLiquidData(uint32 mapId, float x, float y, float z, Optional<uint8> reqLiquidType, AreaAndLiquidData& data) const
{
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
LocationInfo info;
Vector3 pos = convertPositionToInternalRep(x, y, z);
G3D::Vector3 pos = convertPositionToInternalRep(x, y, z);
if (instanceTree->second->GetLocationInfo(pos, info))
{
data.floorZ = info.ground_Z;
@@ -275,7 +272,7 @@ namespace VMAP
std::shared_ptr<ManagedModel> worldmodel; // this is intentionally declared before lock so that it is destroyed after it to prevent deadlocks in releaseModelInstance
//! Critical section, thread safe access to iLoadedModelFiles
std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
std::lock_guard lock(LoadedModelFilesLock);
auto& [key, model] = *iLoadedModelFiles.try_emplace(filename).first;
worldmodel = model.lock();
@@ -298,7 +295,7 @@ namespace VMAP
void VMapManager2::releaseModelInstance(std::string const& filename)
{
//! Critical section, thread safe access to iLoadedModelFiles
std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
std::lock_guard lock(LoadedModelFilesLock);
TC_LOG_DEBUG("maps", "VMapManager2: unloading file '{}'", filename);
@@ -307,14 +304,18 @@ namespace VMAP
TC_LOG_ERROR("misc", "VMapManager2: trying to unload non-loaded file '{}'", filename);
}
LoadResult VMapManager2::existsMap(char const* basePath, unsigned int mapId, int x, int y)
LoadResult VMapManager2::existsMap(std::string const& basePath, uint32 mapId, uint32 x, uint32 y)
{
return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y, this);
return StaticMapTree::CanLoadMap(basePath, mapId, x, y, this);
}
void VMapManager2::getInstanceMapTree(InstanceTreeMap &instanceMapTree)
std::span<ModelInstance const> VMapManager2::getModelsOnMap(uint32 mapId) const
{
instanceMapTree = iInstanceMapTrees;
InstanceTreeMap::const_iterator mapTree = GetMapTree(mapId);
if (mapTree != iInstanceMapTrees.end())
return mapTree->second->getModelInstances();
return {};
}
int32 VMapManager2::getParentMapId(uint32 mapId) const

130
src/common/Collision/Management/VMapManager2.h
View File

@@ -15,13 +15,16 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _VMAPMANAGER2_H
#define _VMAPMANAGER2_H
#ifndef TRINITYCORE_VMAP_MANAGER2_H
#define TRINITYCORE_VMAP_MANAGER2_H
#include "Define.h"
#include "IVMapManager.h"
#include "ModelIgnoreFlags.h"
#include "Optional.h"
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
@@ -37,21 +40,17 @@ Additionally a table to match map ids and map names is used.
//===========================================================
namespace G3D
{
class Vector3;
}
namespace VMAP
{
class ManagedModel;
class ModelInstance;
class StaticMapTree;
class WorldModel;
typedef std::unordered_map<uint32, StaticMapTree*> InstanceTreeMap;
typedef std::unordered_map<uint32, std::unique_ptr<StaticMapTree>> InstanceTreeMap;
typedef std::unordered_map<std::string, std::weak_ptr<ManagedModel>> ModelFileMap;
enum DisableTypes
enum DisableTypes : uint8
{
VMAP_DISABLE_AREAFLAG = 0x1,
VMAP_DISABLE_HEIGHT = 0x2,
@@ -59,61 +58,122 @@ namespace VMAP
VMAP_DISABLE_LIQUIDSTATUS = 0x8
};
class TC_COMMON_API VMapManager2 : public IVMapManager
enum class LoadResult : uint8
{
Success,
FileNotFound,
VersionMismatch,
ReadFromFileFailed,
DisabledInConfig
};
#define VMAP_INVALID_HEIGHT -100000.0f // for check
#define VMAP_INVALID_HEIGHT_VALUE -200000.0f // real assigned value in unknown height case
struct AreaAndLiquidData
{
struct AreaInfo
{
AreaInfo() = default;
AreaInfo(int32 _groupId, int32 _adtId, int32 _rootId, uint32 _mogpFlags, uint32 _uniqueId)
: groupId(_groupId), adtId(_adtId), rootId(_rootId), mogpFlags(_mogpFlags), uniqueId(_uniqueId) { }
int32 groupId = 0;
int32 adtId = 0;
int32 rootId = 0;
uint32 mogpFlags = 0;
uint32 uniqueId = 0;
};
struct LiquidInfo
{
LiquidInfo() = default;
LiquidInfo(uint32 _type, float _level) : type(_type), level(_level) { }
uint32 type = 0;
float level = 0.0f;
};
float floorZ = VMAP_INVALID_HEIGHT;
Optional<AreaInfo> areaInfo;
Optional<LiquidInfo> liquidInfo;
};
class TC_COMMON_API VMapManager2
{
protected:
bool iEnableLineOfSightCalc;
bool iEnableHeightCalc;
bool thread_safe_environment;
// Tree to check collision
ModelFileMap iLoadedModelFiles;
InstanceTreeMap iInstanceMapTrees;
std::unordered_map<uint32, uint32> iParentMapData;
bool thread_safe_environment;
// Mutex for iLoadedModelFiles
std::mutex LoadedModelFilesLock;
static uint32 GetLiquidFlagsDummy(uint32) { return 0; }
static bool IsVMAPDisabledForDummy(uint32 /*entry*/, uint8 /*flags*/) { return false; }
InstanceTreeMap::const_iterator GetMapTree(uint32 mapId) const;
public:
// public for debug
G3D::Vector3 convertPositionToInternalRep(float x, float y, float z) const;
static std::string getMapFileName(unsigned int mapId);
static std::string getMapFileName(uint32 mapId);
static std::string getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY, std::string_view extension);
VMapManager2();
VMapManager2(VMapManager2 const&) = delete;
VMapManager2(VMapManager2&&) = delete;
VMapManager2& operator=(VMapManager2 const&) = delete;
VMapManager2& operator=(VMapManager2&&) = delete;
~VMapManager2();
void InitializeThreadUnsafe(std::unordered_map<uint32, std::vector<uint32>> const& mapData);
void InitializeThreadUnsafe(uint32 mapId, int32 parentMapId);
LoadResult loadMap(char const* 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 ;
/**
fill the hit pos and return true, if an object was hit
Enable/disable LOS calculation
It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
*/
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;
void setEnableLineOfSightCalc(bool enableLineOfSightCalc) { iEnableLineOfSightCalc = enableLineOfSightCalc; }
bool processCommand(char* /*command*/) override { return false; } // for debug and extensions
/**
Enable/disable model height calculation
It is enabled by default. If it is enabled in mid game the maps have to loaded manualy
*/
void setEnableHeightCalc(bool enableHeightCalc) { iEnableHeightCalc = enableHeightCalc; }
bool getAreaAndLiquidData(uint32 mapId, float x, float y, float z, Optional<uint8> reqLiquidType, AreaAndLiquidData& data) const override;
bool isLineOfSightCalcEnabled() const { return iEnableLineOfSightCalc; }
bool isHeightCalcEnabled() const { return iEnableHeightCalc; }
bool isMapLoadingEnabled() const { return iEnableLineOfSightCalc || iEnableHeightCalc; }
LoadResult loadMap(std::string const& basePath, uint32 mapId, uint32 x, uint32 y);
void unloadMap(uint32 mapId, uint32 x, uint32 y);
void unloadMap(uint32 mapId);
bool isInLineOfSight(uint32 mapId, float x1, float y1, float z1, float x2, float y2, float z2, ModelIgnoreFlags ignoreFlags);
/**
test if we hit an object. return true if we hit one. rx, ry, rz will hold the hit position or the dest position, if no intersection was found
return a position, that is modifyDist closer to the origin
*/
bool getObjectHitPos(uint32 mapId, float x1, float y1, float z1, float x2, float y2, float z2, float& rx, float& ry, float& rz, float modifyDist);
float getHeight(uint32 mapId, float x, float y, float z, float maxSearchDist);
/**
Query world model area info.
*/
bool getAreaAndLiquidData(uint32 mapId, float x, float y, float z, Optional<uint8> reqLiquidType, AreaAndLiquidData& data) const;
std::shared_ptr<WorldModel> acquireModelInstance(std::string const& basepath, std::string const& filename);
void releaseModelInstance(std::string const& filename);
// what's the use of this? o.O
virtual std::string getDirFileName(unsigned int mapId, int /*x*/, int /*y*/) const override
static std::string getDirFileName(uint32 mapId, uint32 x, uint32 y)
{
return getMapFileName(mapId);
return getTileFileName(mapId, x, y, "vmtile");
}
virtual LoadResult existsMap(char const* basePath, unsigned int mapId, int x, int y) override;
LoadResult existsMap(std::string const& basePath, uint32 mapId, uint32 x, uint32 y);
void getInstanceMapTree(InstanceTreeMap &instanceMapTree);
std::span<ModelInstance const> getModelsOnMap(uint32 mapId) const;
int32 getParentMapId(uint32 mapId) const;
@@ -125,4 +185,4 @@ namespace VMAP
};
}
#endif
#endif // TRINITYCORE_VMAP_MANAGER2_H

29
src/common/Collision/Maps/MapTree.cpp
View File

@@ -35,7 +35,7 @@ namespace VMAP
{
public:
MapRayCallback(ModelInstance const* val, ModelIgnoreFlags ignoreFlags) : prims(val), hit(false), flags(ignoreFlags) { }
bool operator()(const G3D::Ray& ray, uint32 entry, float& distance, bool pStopAtFirstHit = true)
bool operator()(G3D::Ray const& ray, uint32 entry, float& distance, bool pStopAtFirstHit = true)
{
bool result = prims[entry].intersectRay(ray, distance, pStopAtFirstHit, flags);
if (result)
@@ -69,11 +69,6 @@ namespace VMAP
//=========================================================
std::string getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY, std::string_view extension)
{
return Trinity::StringFormat("{:04}/{:04}_{:02}_{:02}.{}", mapID, mapID, tileY, tileX, extension);
}
bool StaticMapTree::GetLocationInfo(Vector3 const& pos, LocationInfo& info) const
{
LocationInfoCallback intersectionCallBack(iTreeValues.data(), info);
@@ -84,10 +79,8 @@ namespace VMAP
StaticMapTree::StaticMapTree(uint32 mapID, std::string const& basePath)
: iMapID(mapID), iBasePath(basePath)
{
if (iBasePath.length() > 0 && iBasePath[iBasePath.length() - 1] != '/' && iBasePath[iBasePath.length() - 1] != '\\')
{
if (!iBasePath.empty() && iBasePath.back() != '/' && iBasePath.back() != '\\')
iBasePath.push_back('/');
}
}
//=========================================================
@@ -100,7 +93,7 @@ namespace VMAP
Else, pMaxDist is not modified and returns false;
*/
bool StaticMapTree::getIntersectionTime(const G3D::Ray& pRay, float& pMaxDist, bool pStopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
bool StaticMapTree::getIntersectionTime(G3D::Ray const& pRay, float& pMaxDist, bool pStopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
{
float distance = pMaxDist;
MapRayCallback intersectionCallBack(iTreeValues.data(), ignoreFlags);
@@ -209,16 +202,16 @@ namespace VMAP
TileFileOpenResult OpenMapTileFile(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
{
TileFileOpenResult result;
result.Name = basePath + getTileFileName(mapID, tileX, tileY, "vmtile");
result.Name = basePath + VMapManager2::getTileFileName(mapID, tileX, tileY, "vmtile");
result.TileFile.reset(fopen(result.Name.c_str(), "rb"));
result.SpawnIndicesFile.reset(fopen((basePath + getTileFileName(mapID, tileX, tileY, "vmtileidx")).c_str(), "rb"));
result.SpawnIndicesFile.reset(fopen((basePath + VMapManager2::getTileFileName(mapID, tileX, tileY, "vmtileidx")).c_str(), "rb"));
result.UsedMapId = mapID;
if (!result.TileFile)
{
int32 parentMapId = vm->getParentMapId(mapID);
while (parentMapId != -1)
{
result.Name = basePath + getTileFileName(parentMapId, tileX, tileY, "vmtile");
result.Name = basePath + VMapManager2::getTileFileName(parentMapId, tileX, tileY, "vmtile");
result.TileFile.reset(fopen(result.Name.c_str(), "rb"));
result.UsedMapId = parentMapId;
if (result.TileFile)
@@ -232,11 +225,12 @@ namespace VMAP
}
//=========================================================
LoadResult StaticMapTree::CanLoadMap(const std::string& vmapPath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
LoadResult StaticMapTree::CanLoadMap(std::string const& vmapPath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
{
std::string basePath = vmapPath;
if (basePath.length() > 0 && basePath[basePath.length() - 1] != '/' && basePath[basePath.length() - 1] != '\\')
if (!basePath.empty() && basePath.back() != '/' && basePath.back() != '\\')
basePath.push_back('/');
std::string fullname = basePath + VMapManager2::getMapFileName(mapID);
auto rf = Trinity::make_unique_ptr_with_deleter<&::fclose>(fopen(fullname.c_str(), "rb"));
@@ -436,9 +430,8 @@ namespace VMAP
"Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
}
void StaticMapTree::getModelInstances(ModelInstance*& models, uint32& count)
std::span<ModelInstance const> StaticMapTree::getModelInstances() const
{
models = iTreeValues.data();
count = iTreeValues.size();
return iTreeValues;
}
}

21
src/common/Collision/Maps/MapTree.h
View File

@@ -20,6 +20,7 @@
#include "Define.h"
#include "BoundingIntervalHierarchy.h"
#include <span>
#include <unordered_map>
namespace VMAP
@@ -60,27 +61,27 @@ namespace VMAP
std::string iBasePath;
private:
bool getIntersectionTime(const G3D::Ray& pRay, float &pMaxDist, bool pStopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
bool getIntersectionTime(G3D::Ray const& pRay, float& pMaxDist, bool pStopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
//bool containsLoadedMapTile(unsigned int pTileIdent) const { return(iLoadedMapTiles.containsKey(pTileIdent)); }
public:
static uint32 packTileID(uint32 tileX, uint32 tileY) { return tileX<<16 | tileY; }
static void unpackTileID(uint32 ID, uint32 &tileX, uint32 &tileY) { tileX = ID >> 16; tileY = ID & 0xFF; }
static LoadResult CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
static uint32 packTileID(uint32 tileX, uint32 tileY) { return tileX << 16 | tileY; }
static void unpackTileID(uint32 ID, uint32& tileX, uint32& tileY) { tileX = ID >> 16; tileY = ID & 0xFF; }
static LoadResult CanLoadMap(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
StaticMapTree(uint32 mapID, const std::string &basePath);
StaticMapTree(uint32 mapID, std::string const& basePath);
~StaticMapTree();
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 GetLocationInfo(const G3D::Vector3 &pos, LocationInfo &info) const;
bool isInLineOfSight(G3D::Vector3 const& pos1, G3D::Vector3 const& pos2, ModelIgnoreFlags ignoreFlags) const;
bool getObjectHitPos(G3D::Vector3 const& pos1, G3D::Vector3 const& pos2, G3D::Vector3& pResultHitPos, float pModifyDist) const;
float getHeight(G3D::Vector3 const& pPos, float maxSearchDist) const;
bool GetLocationInfo(G3D::Vector3 const& pos, LocationInfo& info) const;
LoadResult InitMap(std::string const& fname);
void UnloadMap();
LoadResult LoadMapTile(uint32 tileX, uint32 tileY, VMapManager2* vm);
void UnloadMapTile(uint32 tileX, uint32 tileY, VMapManager2* vm);
uint32 numLoadedTiles() const { return uint32(iLoadedTiles.size()); }
void getModelInstances(ModelInstance* &models, uint32 &count);
std::span<ModelInstance const> getModelInstances() const;
private:
StaticMapTree(StaticMapTree const& right) = delete;

8
src/server/game/Globals/ObjectMgr.cpp
View File

@@ -2197,7 +2197,7 @@ void ObjectMgr::LoadCreatures()
if (sWorld->getBoolConfig(CONFIG_CREATURE_CHECK_INVALID_POSITION))
{
if (VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
if (VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
{
if (vmgr->isMapLoadingEnabled() && !IsTransportMap(data.mapId))
{
@@ -2205,7 +2205,7 @@ void ObjectMgr::LoadCreatures()
int gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
int gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
VMAP::LoadResult result = vmgr->existsMap((sWorld->GetDataPath() + "vmaps").c_str(), data.mapId, gx, gy);
VMAP::LoadResult result = vmgr->existsMap(sWorld->GetDataPath() + "vmaps", data.mapId, gx, gy);
if (result != VMAP::LoadResult::Success)
TC_LOG_ERROR("sql.sql", "Table `creature` has creature (GUID: {} Entry: {} MapID: {}) spawned on a possible invalid position ({})",
guid, data.id, data.mapId, data.spawnPoint.ToString());
@@ -2553,7 +2553,7 @@ void ObjectMgr::LoadGameObjects()
if (sWorld->getBoolConfig(CONFIG_GAME_OBJECT_CHECK_INVALID_POSITION))
{
if (VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
if (VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
{
if (vmgr->isMapLoadingEnabled() && !IsTransportMap(data.mapId))
{
@@ -2561,7 +2561,7 @@ void ObjectMgr::LoadGameObjects()
int gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
int gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
VMAP::LoadResult result = vmgr->existsMap((sWorld->GetDataPath() + "vmaps").c_str(), data.mapId, gx, gy);
VMAP::LoadResult result = vmgr->existsMap(sWorld->GetDataPath() + "vmaps", data.mapId, gx, gy);
if (result != VMAP::LoadResult::Success)
TC_LOG_ERROR("sql.sql", "Table `gameobject` has gameobject (GUID: {} Entry: {} MapID: {}) spawned on a possible invalid position ({})",
guid, data.id, data.mapId, data.spawnPoint.ToString());

27
src/server/game/Maps/TerrainMgr.cpp
View File

@@ -109,30 +109,30 @@ bool TerrainInfo::ExistMap(uint32 mapid, int32 gx, int32 gy, bool log /*= true*/
bool TerrainInfo::ExistVMap(uint32 mapid, int32 gx, int32 gy)
{
if (VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
if (VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager())
{
if (vmgr->isMapLoadingEnabled())
{
VMAP::LoadResult result = vmgr->existsMap((sWorld->GetDataPath() + "vmaps").c_str(), mapid, gx, gy);
std::string name = vmgr->getDirFileName(mapid, gx, gy);
VMAP::LoadResult result = vmgr->existsMap(sWorld->GetDataPath() + "vmaps", mapid, gx, gy);
std::string name = VMAP::VMapManager2::getDirFileName(mapid, gx, gy);
switch (result)
{
case VMAP::LoadResult::Success:
break;
case VMAP::LoadResult::FileNotFound:
TC_LOG_ERROR("maps", "VMap file '{}' does not exist", (sWorld->GetDataPath() + "vmaps/" + name));
TC_LOG_ERROR("maps", "VMap file '{}vmaps/{}' does not exist", sWorld->GetDataPath(), name);
TC_LOG_ERROR("maps", "Please place VMAP files (*.vmtree and *.vmtile) in the vmap directory ({}), or correct the DataDir setting in your worldserver.conf file.", (sWorld->GetDataPath() + "vmaps/"));
return false;
case VMAP::LoadResult::VersionMismatch:
TC_LOG_ERROR("maps", "VMap file '{}' couldn't be loaded", (sWorld->GetDataPath() + "vmaps/" + name));
TC_LOG_ERROR("maps", "VMap file '{}vmaps/{}' couldn't be loaded", sWorld->GetDataPath(), name);
TC_LOG_ERROR("maps", "This is because the version of the VMap file and the version of this module are different, please re-extract the maps with the tools compiled with this module.");
return false;
case VMAP::LoadResult::ReadFromFileFailed:
TC_LOG_ERROR("maps", "VMap file '{}' couldn't be loaded", (sWorld->GetDataPath() + "vmaps/" + name));
TC_LOG_ERROR("maps", "VMap file '{}vmaps/{}' couldn't be loaded", sWorld->GetDataPath(), name);
TC_LOG_ERROR("maps", "This is because VMAP files are corrupted, please re-extract the maps with the tools compiled with this module.");
return false;
case VMAP::LoadResult::DisabledInConfig:
TC_LOG_ERROR("maps", "VMap file '{}' couldn't be loaded", (sWorld->GetDataPath() + "vmaps/" + name));
TC_LOG_ERROR("maps", "VMap file '{}vmaps/{}' couldn't be loaded", sWorld->GetDataPath(), name);
TC_LOG_ERROR("maps", "This is because VMAP is disabled in config file.");
return false;
}
@@ -215,9 +215,8 @@ void TerrainInfo::LoadVMap(int32 gx, int32 gy)
{
if (!VMAP::VMapFactory::createOrGetVMapManager()->isMapLoadingEnabled())
return;
// x and y are swapped !!
VMAP::LoadResult vmapLoadResult = VMAP::VMapFactory::createOrGetVMapManager()->loadMap((sWorld->GetDataPath() + "vmaps").c_str(), GetId(), gx, gy);
switch (vmapLoadResult)
switch (VMAP::VMapFactory::createOrGetVMapManager()->loadMap(sWorld->GetDataPath() + "vmaps", GetId(), gx, gy))
{
case VMAP::LoadResult::Success:
TC_LOG_DEBUG("maps", "VMAP loaded name:{}, id:{}, x:{}, y:{} (vmap rep.: x:{}, y:{})", GetMapName(), GetId(), gx, gy, gx, gy);
@@ -335,7 +334,7 @@ static bool IsInWMOInterior(uint32 mogpFlags)
void TerrainInfo::GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, PositionFullTerrainStatus& data,
Optional<map_liquidHeaderTypeFlags> reqLiquidType, float collisionHeight, DynamicMapTree const* dynamicMapTree)
{
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::AreaAndLiquidData vmapData;
VMAP::AreaAndLiquidData dynData;
VMAP::AreaAndLiquidData* wmoData = nullptr;
@@ -485,7 +484,7 @@ void TerrainInfo::GetFullTerrainStatusForPosition(PhaseShift const& phaseShift,
ZLiquidStatus TerrainInfo::GetLiquidStatus(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, Optional<map_liquidHeaderTypeFlags> ReqLiquidType, LiquidData* data, float collisionHeight)
{
ZLiquidStatus result = LIQUID_MAP_NO_WATER;
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::AreaAndLiquidData vmapData;
bool useGridLiquid = true;
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, mapId, this, x, y);
@@ -586,7 +585,7 @@ bool TerrainInfo::GetAreaInfo(PhaseShift const& phaseShift, uint32 mapId, float
{
float check_z = z;
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, mapId, this, x, y);
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::AreaAndLiquidData vdata;
VMAP::AreaAndLiquidData ddata;
@@ -704,7 +703,7 @@ float TerrainInfo::GetStaticHeight(PhaseShift const& phaseShift, uint32 mapId, f
float vmapHeight = VMAP_INVALID_HEIGHT_VALUE;
if (checkVMap)
{
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
VMAP::VMapManager2* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
if (vmgr->isHeightCalcEnabled())
vmapHeight = vmgr->getHeight(terrainMapId, x, y, z, maxSearchDist);
}

17
src/tools/mmaps_generator/TerrainBuilder.cpp
View File

@@ -589,23 +589,12 @@ namespace MMAP
if (result != VMAP::LoadResult::Success)
break;
VMAP::InstanceTreeMap instanceTrees;
vmapManager->getInstanceMapTree(instanceTrees);
if (!instanceTrees[mapID])
std::span<VMAP::ModelInstance const> models = vmapManager->getModelsOnMap(mapID);
if (models.empty())
break;
VMAP::ModelInstance* models = nullptr;
uint32 count = 0;
instanceTrees[mapID]->getModelInstances(models, count);
if (!models)
break;
for (uint32 i = 0; i < count; ++i)
for (VMAP::ModelInstance const& instance : models)
{
VMAP::ModelInstance const& instance = models[i];
// model instances exist in tree even though there are instances of that model in this tile
VMAP::WorldModel const* worldModel = instance.getWorldModel();
if (!worldModel)