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: Implement loading phased tiles

Browse Source 
Closes #15163
This commit is contained in:
Shauren
2018-02-24 21:07:08 +01:00
parent 91be2332e2
commit 4798d9ce7a
21 changed files with 474 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -94,6 +94,8 @@ namespace VMAP
*/
virtual bool getAreaInfo(unsigned int pMapId, float x, float y, float &z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const=0;
virtual bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const=0;
virtual int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const = 0;
};
}

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

@@ -40,23 +40,35 @@ namespace VMAP
thread_safe_environment = true;
}
VMapManager2::~VMapManager2(void)
VMapManager2::~VMapManager2()
{
for (InstanceTreeMap::iterator i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
{
for (auto i = iInstanceMapTrees.begin(); i != iInstanceMapTrees.end(); ++i)
delete i->second;
}
for (ModelFileMap::iterator i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
{
for (auto i = iLoadedModelFiles.begin(); i != iLoadedModelFiles.end(); ++i)
delete i->second.getModel();
}
}
void VMapManager2::InitializeThreadUnsafe(const std::vector<uint32>& mapIds)
InstanceTreeMap::const_iterator VMapManager2::GetMapTree(uint32 mapId) const
{
// return the iterator if found or end() if not found/NULL
auto itr = iInstanceMapTrees.find(mapId);
if (itr != iInstanceMapTrees.cend() && !itr->second)
itr = iInstanceMapTrees.cend();
return itr;
}
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 (uint32 const& mapId : mapIds)
iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId, nullptr));
iChildMapData = mapData;
for (std::pair<uint32 const, std::vector<uint32>> const& mapId : mapData)
{
iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId.first, nullptr));
for (uint32 childMapId : mapId.second)
iParentMapData[childMapId] = mapId.first;
}
thread_safe_environment = false;
}
@@ -87,8 +99,15 @@ namespace VMAP
int result = VMAP_LOAD_RESULT_IGNORED;
if (isMapLoadingEnabled())
{
if (_loadMap(mapId, basePath, x, y))
if (loadSingleMap(mapId, basePath, x, y))
{
result = VMAP_LOAD_RESULT_OK;
auto childMaps = iChildMapData.find(mapId);
if (childMaps != iChildMapData.end())
for (uint32 childMapId : childMaps->second)
if (!loadSingleMap(childMapId, basePath, x, y))
result = VMAP_LOAD_RESULT_ERROR;
}
else
result = VMAP_LOAD_RESULT_ERROR;
}
@@ -96,20 +115,10 @@ namespace VMAP
return result;
}
InstanceTreeMap::const_iterator VMapManager2::GetMapTree(uint32 mapId) const
{
// 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;
}
// load one tile (internal use only)
bool VMapManager2::_loadMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY)
bool VMapManager2::loadSingleMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY)
{
InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
auto instanceTree = iInstanceMapTrees.find(mapId);
if (instanceTree == iInstanceMapTrees.end())
{
if (thread_safe_environment)
@@ -134,12 +143,22 @@ namespace VMAP
return instanceTree->second->LoadMapTile(tileX, tileY, this);
}
void VMapManager2::unloadMap(unsigned int mapId)
void VMapManager2::unloadMap(unsigned int mapId, int x, int y)
{
InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
auto childMaps = iChildMapData.find(mapId);
if (childMaps != iChildMapData.end())
for (uint32 childMapId : childMaps->second)
unloadSingleMap(childMapId, x, y);
unloadSingleMap(mapId, x, y);
}
void VMapManager2::unloadSingleMap(uint32 mapId, int x, int y)
{
auto instanceTree = iInstanceMapTrees.find(mapId);
if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
{
instanceTree->second->UnloadMap(this);
instanceTree->second->UnloadMapTile(x, y, this);
if (instanceTree->second->numLoadedTiles() == 0)
{
delete instanceTree->second;
@@ -148,12 +167,22 @@ namespace VMAP
}
}
void VMapManager2::unloadMap(unsigned int mapId, int x, int y)
void VMapManager2::unloadMap(unsigned int mapId)
{
InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId);
auto childMaps = iChildMapData.find(mapId);
if (childMaps != iChildMapData.end())
for (uint32 childMapId : childMaps->second)
unloadSingleMap(childMapId);
unloadSingleMap(mapId);
}
void VMapManager2::unloadSingleMap(uint32 mapId)
{
auto instanceTree = iInstanceMapTrees.find(mapId);
if (instanceTree != iInstanceMapTrees.end() && instanceTree->second)
{
instanceTree->second->UnloadMapTile(x, y, this);
instanceTree->second->UnloadMap(this);
if (instanceTree->second->numLoadedTiles() == 0)
{
delete instanceTree->second;
@@ -167,15 +196,13 @@ namespace VMAP
if (!isLineOfSightCalcEnabled() || IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
return true;
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
auto 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;
@@ -189,7 +216,7 @@ namespace VMAP
{
if (isLineOfSightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LOS))
{
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos1 = convertPositionToInternalRep(x1, y1, z1);
@@ -219,7 +246,7 @@ namespace VMAP
{
if (isHeightCalcEnabled() && !IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_HEIGHT))
{
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos = convertPositionToInternalRep(x, y, z);
@@ -238,7 +265,7 @@ namespace VMAP
{
if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_AREAFLAG))
{
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
Vector3 pos = convertPositionToInternalRep(x, y, z);
@@ -256,7 +283,7 @@ namespace VMAP
{
if (!IsVMAPDisabledForPtr(mapId, VMAP_DISABLE_LIQUIDSTATUS))
{
InstanceTreeMap::const_iterator instanceTree = GetMapTree(mapId);
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
{
LocationInfo info;
@@ -279,12 +306,21 @@ namespace VMAP
return false;
}
int32 VMapManager2::GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const
{
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
return instanceTree->second->GetDistanceToClosestPrimaryTile(x, y);
return std::numeric_limits<int32>::max();
}
WorldModel* 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);
auto model = iLoadedModelFiles.find(filename);
if (model == iLoadedModelFiles.end())
{
WorldModel* worldmodel = new WorldModel();
@@ -307,7 +343,7 @@ namespace VMAP
//! Critical section, thread safe access to iLoadedModelFiles
std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
ModelFileMap::iterator model = iLoadedModelFiles.find(filename);
auto model = iLoadedModelFiles.find(filename);
if (model == iLoadedModelFiles.end())
{
VMAP_ERROR_LOG("misc", "VMapManager2: trying to unload non-loaded file '%s'", filename.c_str());
@@ -323,7 +359,7 @@ namespace VMAP
bool VMapManager2::existsMap(const char* basePath, unsigned int mapId, int x, int y)
{
return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y);
return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y, this);
}
void VMapManager2::getInstanceMapTree(InstanceTreeMap &instanceMapTree)
@@ -331,4 +367,13 @@ namespace VMAP
instanceMapTree = iInstanceMapTrees;
}
int32 VMapManager2::getParentMapId(uint32 mapId) const
{
auto itr = iParentMapData.find(mapId);
if (itr != iParentMapData.end())
return int32(itr->second);
return -1;
}
} // namespace VMAP

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

@@ -81,13 +81,12 @@ namespace VMAP
// Tree to check collision
ModelFileMap iLoadedModelFiles;
InstanceTreeMap iInstanceMapTrees;
std::unordered_map<uint32, std::vector<uint32>> iChildMapData;
std::unordered_map<uint32, uint32> iParentMapData;
bool thread_safe_environment;
// Mutex for iLoadedModelFiles
std::mutex LoadedModelFilesLock;
bool _loadMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY);
/* void _unloadMap(uint32 pMapId, uint32 x, uint32 y); */
static uint32 GetLiquidFlagsDummy(uint32) { return 0; }
static bool IsVMAPDisabledForDummy(uint32 /*entry*/, uint8 /*flags*/) { return false; }
@@ -99,13 +98,18 @@ namespace VMAP
static std::string getMapFileName(unsigned int mapId);
VMapManager2();
~VMapManager2(void);
~VMapManager2();
void InitializeThreadUnsafe(std::unordered_map<uint32, std::vector<uint32>> const& mapData);
void InitializeThreadUnsafe(const std::vector<uint32>& mapIds);
int loadMap(const char* pBasePath, unsigned int mapId, int x, int y) override;
bool loadSingleMap(uint32 mapId, const std::string& basePath, uint32 tileX, uint32 tileY);
void unloadMap(unsigned int mapId, int x, int y) override;
void unloadSingleMap(uint32 mapId, int x, int y);
void unloadMap(unsigned int mapId) override;
void unloadSingleMap(uint32 mapId);
bool isInLineOfSight(unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2) override ;
/**
@@ -119,6 +123,8 @@ namespace VMAP
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;
int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const override;
WorldModel* acquireModelInstance(const std::string& basepath, const std::string& filename);
void releaseModelInstance(const std::string& filename);
@@ -131,6 +137,8 @@ namespace VMAP
void getInstanceMapTree(InstanceTreeMap &instanceMapTree);
int32 getParentMapId(uint32 mapId) const;
typedef uint32(*GetLiquidFlagsFn)(uint32 liquidType);
GetLiquidFlagsFn GetLiquidFlagsPtr;

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

@@ -237,9 +237,29 @@ namespace VMAP
return(height);
}
StaticMapTree::TileFileOpenResult StaticMapTree::OpenMapTileFile(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm)
{
TileFileOpenResult result;
result.Name = basePath + getTileFileName(mapID, tileX, tileY);
result.File = fopen(result.Name.c_str(), "rb");
result.IsPrimary = true;
if (!result.File)
{
int32 parentMapId = vm->getParentMapId(mapID);
if (parentMapId != -1)
{
result.Name = basePath + getTileFileName(parentMapId, tileX, tileY);
result.File = fopen(result.Name.c_str(), "rb");
result.IsPrimary = false;
}
}
return result;
}
//=========================================================
bool StaticMapTree::CanLoadMap(const std::string &vmapPath, uint32 mapID, uint32 tileX, uint32 tileY)
bool StaticMapTree::CanLoadMap(const std::string &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] != '\\')
@@ -259,8 +279,7 @@ namespace VMAP
}
if (tiled)
{
std::string tilefile = basePath + getTileFileName(mapID, tileX, tileY);
FILE* tf = fopen(tilefile.c_str(), "rb");
FILE* tf = OpenMapTileFile(basePath, mapID, tileX, tileY, vm).File;
if (!tf)
success = false;
else
@@ -321,6 +340,22 @@ namespace VMAP
}
}
if (success)
{
success = readChunk(rf, chunk, "SIDX", 4);
uint32 spawnIndicesSize = 0;
uint32 spawnId;
uint32 spawnIndex;
if (success && fread(&spawnIndicesSize, sizeof(uint32), 1, rf) != 1) success = false;
for (uint32 i = 0; i < spawnIndicesSize && success; ++i)
{
if (fread(&spawnId, sizeof(uint32), 1, rf) == 1 && fread(&spawnIndex, sizeof(uint32), 1, rf) == 1)
iSpawnIndices[spawnId] = spawnIndex;
else
success = false;
}
}
fclose(rf);
return success;
}
@@ -337,6 +372,7 @@ namespace VMAP
}
iLoadedSpawns.clear();
iLoadedTiles.clear();
iLoadedPrimaryTiles.clear();
}
//=========================================================
@@ -357,22 +393,21 @@ namespace VMAP
}
bool result = true;
std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
FILE* tf = fopen(tilefile.c_str(), "rb");
if (tf)
TileFileOpenResult fileResult = OpenMapTileFile(iBasePath, iMapID, tileX, tileY, vm);
if (fileResult.File)
{
char chunk[8];
if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
if (!readChunk(fileResult.File, chunk, VMAP_MAGIC, 8))
result = false;
uint32 numSpawns = 0;
if (result && fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
if (result && fread(&numSpawns, sizeof(uint32), 1, fileResult.File) != 1)
result = false;
for (uint32 i=0; i<numSpawns && result; ++i)
{
// read model spawns
ModelSpawn spawn;
result = ModelSpawn::readFromFile(tf, spawn);
result = ModelSpawn::readFromFile(fileResult.File, spawn);
if (result)
{
// acquire model instance
@@ -381,15 +416,15 @@ namespace VMAP
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)
auto spawnIndex = iSpawnIndices.find(spawn.ID);
if (spawnIndex != iSpawnIndices.end())
{
uint32 referencedVal = spawnIndex->second;
if (!iLoadedSpawns.count(referencedVal))
{
if (referencedVal > iNTreeValues)
if (referencedVal >= iNTreeValues)
{
VMAP_ERROR_LOG("maps", "StaticMapTree::LoadMapTile() : invalid tree element (%u/%u) referenced in tile %s", referencedVal, iNTreeValues, tilefile.c_str());
VMAP_ERROR_LOG("maps", "StaticMapTree::LoadMapTile() : invalid tree element (%u/%u) referenced in tile %s", referencedVal, iNTreeValues, fileResult.Name.c_str());
continue;
}
@@ -412,7 +447,9 @@ namespace VMAP
}
}
iLoadedTiles[packTileID(tileX, tileY)] = true;
fclose(tf);
if (fileResult.IsPrimary)
iLoadedPrimaryTiles.emplace_back(tileX, tileY);
fclose(fileResult.File);
}
else
iLoadedTiles[packTileID(tileX, tileY)] = false;
@@ -434,34 +471,33 @@ namespace VMAP
}
if (tile->second) // file associated with tile
{
std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
FILE* tf = fopen(tilefile.c_str(), "rb");
if (tf)
TileFileOpenResult fileResult = OpenMapTileFile(iBasePath, iMapID, tileX, tileY, vm);
if (fileResult.File)
{
bool result=true;
char chunk[8];
if (!readChunk(tf, chunk, VMAP_MAGIC, 8))
if (!readChunk(fileResult.File, chunk, VMAP_MAGIC, 8))
result = false;
uint32 numSpawns;
if (fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
if (fread(&numSpawns, sizeof(uint32), 1, fileResult.File) != 1)
result = false;
for (uint32 i=0; i<numSpawns && result; ++i)
{
// read model spawns
ModelSpawn spawn;
result = ModelSpawn::readFromFile(tf, spawn);
result = ModelSpawn::readFromFile(fileResult.File, spawn);
if (result)
{
// release model instance
vm->releaseModelInstance(spawn.name);
// update tree
uint32 referencedNode;
if (fread(&referencedNode, sizeof(uint32), 1, tf) != 1)
auto spawnIndex = iSpawnIndices.find(spawn.ID);
if (spawnIndex == iSpawnIndices.end())
result = false;
else
{
uint32 referencedNode = spawnIndex->second;
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)
@@ -472,10 +508,12 @@ namespace VMAP
}
}
}
fclose(tf);
fclose(fileResult.File);
}
}
iLoadedTiles.erase(tile);
iLoadedPrimaryTiles.erase(std::remove_if(iLoadedPrimaryTiles.begin(), iLoadedPrimaryTiles.end(),
[tileX, tileY](std::pair<uint32, uint32> const& p) { return p.first == tileX && p.second == tileY; }), iLoadedPrimaryTiles.end());
TC_METRIC_EVENT("map_events", "UnloadMapTile",
"Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
}
@@ -485,4 +523,13 @@ namespace VMAP
models = iTreeValues;
count = iNTreeValues;
}
int32 StaticMapTree::GetDistanceToClosestPrimaryTile(int32 x, int32 y) const
{
int32 minDistance = std::numeric_limits<int32>::max();
for (std::pair<int32, int32> const& primaryTile : iLoadedPrimaryTiles)
minDistance = std::min(minDistance, (primaryTile.first - x) * (primaryTile.first - x) + (primaryTile.second - y) * (primaryTile.second - y));
return minDistance;
}
}

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

@@ -47,23 +47,33 @@ namespace VMAP
BIH iTree;
ModelInstance* iTreeValues; // the tree entries
uint32 iNTreeValues;
std::unordered_map<uint32, uint32> iSpawnIndices;
// Store all the map tile idents that are loaded for that map
// some maps are not splitted into tiles and we have to make sure, not removing the map before all tiles are removed
// empty tiles have no tile file, hence map with bool instead of just a set (consistency check)
loadedTileMap iLoadedTiles;
std::vector<std::pair<int32, int32>> iLoadedPrimaryTiles;
// stores <tree_index, reference_count> to invalidate tree values, unload map, and to be able to report errors
loadedSpawnMap iLoadedSpawns;
std::string iBasePath;
struct TileFileOpenResult
{
FILE* File;
std::string Name;
bool IsPrimary;
};
private:
static TileFileOpenResult OpenMapTileFile(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
bool getIntersectionTime(const G3D::Ray& pRay, float &pMaxDist, bool pStopAtFirstHit) const;
//bool containsLoadedMapTile(unsigned int pTileIdent) const { return(iLoadedMapTiles.containsKey(pTileIdent)); }
public:
static std::string getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY);
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 bool CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY);
static void unpackTileID(uint32 ID, uint32 &tileX, uint32 &tileY) { tileX = ID >> 16; tileY = ID & 0xFF; }
static bool CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm);
StaticMapTree(uint32 mapID, const std::string &basePath);
~StaticMapTree();
@@ -82,6 +92,8 @@ namespace VMAP
uint32 numLoadedTiles() const { return uint32(iLoadedTiles.size()); }
void getModelInstances(ModelInstance* &models, uint32 &count);
int32 GetDistanceToClosestPrimaryTile(int32 x, int32 y) const;
private:
StaticMapTree(StaticMapTree const& right) = delete;
StaticMapTree& operator=(StaticMapTree const& right) = delete;

34
src/common/Collision/Maps/TileAssembler.cpp
View File

@@ -84,7 +84,7 @@ namespace VMAP
if (entry->second.flags & MOD_M2)
{
if (!calculateTransformedBound(entry->second))
break;
continue;
}
else if (entry->second.flags & MOD_WORLDSPAWN) // WMO maps and terrain maps use different origin, so we need to adapt :/
{
@@ -92,7 +92,7 @@ namespace VMAP
//entry->second.iPos += Vector3(533.33333f*32, 533.33333f*32, 0.f);
entry->second.iBound = entry->second.iBound + Vector3(533.33333f*32, 533.33333f*32, 0.f);
}
mapSpawns.push_back(&(entry->second));
mapSpawns.push_back(&entry->second);
spawnedModelFiles.insert(entry->second.name);
}
@@ -110,9 +110,6 @@ namespace VMAP
}
// ===> possibly move this code to StaticMapTree class
std::map<uint32, uint32> modelNodeIdx;
for (uint32 i=0; i<mapSpawns.size(); ++i)
modelNodeIdx.insert(pair<uint32, uint32>(mapSpawns[i]->ID, i));
// write map tree file
std::stringstream mapfilename;
@@ -139,7 +136,17 @@ namespace VMAP
for (TileMap::iterator glob=globalRange.first; glob != globalRange.second && success; ++glob)
{
success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second]);
success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second.Id]);
}
// spawn id to index map
if (success && fwrite("SIDX", 4, 1, mapfile) != 1) success = false;
uint32 mapSpawnsSize = mapSpawns.size();
if (success && fwrite(&mapSpawnsSize, sizeof(uint32), 1, mapfile) != 1) success = false;
for (uint32 i = 0; i < mapSpawnsSize; ++i)
{
if (success && fwrite(&mapSpawns[i]->ID, sizeof(uint32), 1, mapfile) != 1) success = false;
if (success && fwrite(&i, sizeof(uint32), 1, mapfile) != 1) success = false;
}
fclose(mapfile);
@@ -151,8 +158,9 @@ namespace VMAP
TileMap::iterator tile;
for (tile = tileEntries.begin(); tile != tileEntries.end(); ++tile)
{
const ModelSpawn &spawn = map_iter->second->UniqueEntries[tile->second];
if (spawn.flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
if (tile->second.Flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
continue;
if (tile->second.Flags & MOD_PARENT_SPAWN) // tile belongs to parent map
continue;
uint32 nSpawns = tileEntries.count(tile->first);
std::stringstream tilefilename;
@@ -172,16 +180,12 @@ namespace VMAP
{
if (s)
++tile;
const ModelSpawn &spawn2 = map_iter->second->UniqueEntries[tile->second];
const ModelSpawn &spawn2 = map_iter->second->UniqueEntries[tile->second.Id];
success = success && ModelSpawn::writeToFile(tilefile, spawn2);
// MapTree nodes to update when loading tile:
std::map<uint32, uint32>::iterator nIdx = modelNodeIdx.find(spawn2.ID);
if (success && fwrite(&nIdx->second, sizeof(uint32), 1, tilefile) != 1) success = false;
}
fclose(tilefile);
}
}
// break; //test, extract only first map; TODO: remvoe this line
}
// add an object models, listed in temp_gameobject_models file
@@ -239,9 +243,9 @@ namespace VMAP
printf("spawning Map %u\n", mapID);
mapData[mapID] = current = new MapSpawns();
}
else current = (*map_iter).second;
else current = map_iter->second;
current->UniqueEntries.insert(pair<uint32, ModelSpawn>(spawn.ID, spawn));
current->TileEntries.insert(pair<uint32, uint32>(StaticMapTree::packTileID(tileX, tileY), spawn.ID));
current->TileEntries.insert(pair<uint32, TileSpawn>(StaticMapTree::packTileID(tileX, tileY), TileSpawn{ spawn.ID, spawn.flags }));
}
bool success = (ferror(dirf) == 0);
fclose(dirf);

8
src/common/Collision/Maps/TileAssembler.h
View File

@@ -52,8 +52,14 @@ namespace VMAP
void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; }
};
struct TileSpawn
{
uint32 Id;
uint32 Flags;
};
typedef std::map<uint32, ModelSpawn> UniqueEntryMap;
typedef std::multimap<uint32, uint32> TileMap;
typedef std::multimap<uint32, TileSpawn> TileMap;
struct TC_COMMON_API MapSpawns
{

5
src/common/Collision/Models/ModelInstance.h
View File

@@ -35,8 +35,9 @@ namespace VMAP
enum ModelFlags
{
MOD_M2 = 1,
MOD_WORLDSPAWN = 1<<1,
MOD_HAS_BOUND = 1<<2
MOD_WORLDSPAWN = 1 << 1,
MOD_HAS_BOUND = 1 << 2,
MOD_PARENT_SPAWN = 1 << 3
};
class TC_COMMON_API ModelSpawn

4
src/common/Collision/VMapDefinitions.h
View File

@@ -25,8 +25,8 @@
namespace VMAP
{
const char VMAP_MAGIC[] = "VMAP_4.5";
const char RAW_VMAP_MAGIC[] = "VMAP045"; // used in extracted vmap files with raw data
const char VMAP_MAGIC[] = "VMAP_4.6";
const char RAW_VMAP_MAGIC[] = "VMAP046"; // used in extracted vmap files with raw data
const char GAMEOBJECT_MODELS[] = "GameObjectModels.dtree";
// defined in TileAssembler.cpp currently...

8
src/server/game/World/World.cpp
View File

@@ -1576,11 +1576,17 @@ void World::SetInitialWorldSettings()
sTaxiPathGraph.Initialize();
std::vector<uint32> mapIds;
std::unordered_map<uint32, std::vector<uint32>> mapData;
for (MapEntry const* mapEntry : sMapStore)
{
mapIds.push_back(mapEntry->ID);
mapData.emplace(std::piecewise_construct, std::forward_as_tuple(mapEntry->ID), std::forward_as_tuple());
if (mapEntry->ParentMapID != -1)
mapData[mapEntry->ParentMapID].push_back(mapEntry->ID);
}
if (VMAP::VMapManager2* vmmgr2 = dynamic_cast<VMAP::VMapManager2*>(VMAP::VMapFactory::createOrGetVMapManager()))
vmmgr2->InitializeThreadUnsafe(mapIds);
vmmgr2->InitializeThreadUnsafe(mapData);
MMAP::MMapManager* mmmgr = MMAP::MMapFactory::createOrGetMMapManager();
mmmgr->InitializeThreadUnsafe(mapIds);

2
src/tools/mmaps_generator/MapBuilder.cpp
View File

@@ -216,7 +216,7 @@ namespace MMAP
_workerThreads.push_back(std::thread(&MapBuilder::WorkerThread, this));
}
m_tiles.sort([](MapTiles a, MapTiles b)
m_tiles.sort([](MapTiles const& a, MapTiles const& b)
{
return a.m_tiles->size() > b.m_tiles->size();
});

49
src/tools/vmap4_extractor/adtfile.cpp
View File

@@ -79,26 +79,33 @@ char* GetExtension(char* FileName)
extern CASC::StorageHandle CascStorage;
ADTFile::ADTFile(char* filename) : ADT(CascStorage, filename, false), nWMO(0), nMDX(0)
ADTFile::ADTFile(char* filename, bool cache) : ADT(CascStorage, filename, false), nWMO(0), nMDX(0)
{
Adtfilename.append(filename);
cacheable = cache;
dirfileCache = nullptr;
}
bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId)
{
if (dirfileCache)
return initFromCache(map_num, tileX, tileY, originalMapId);
if (ADT.isEof())
return false;
uint32 size;
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE *dirfile;
dirfile = fopen(dirname.c_str(), "ab");
FILE* dirfile = fopen(dirname.c_str(), "ab");
if(!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
if (cacheable)
dirfileCache = new std::vector<ADTOutputCache>();
while (!ADT.isEof())
{
char fourcc[5];
@@ -173,7 +180,7 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
{
uint32 id;
ADT.read(&id, 4);
ModelInstance inst(ADT, ModelInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
ModelInstance inst(ADT, ModelInstanceNames[id].c_str(), map_num, tileX, tileY, originalMapId, dirfile, dirfileCache);
}
ModelInstanceNames.clear();
@@ -188,7 +195,7 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
{
uint32 id;
ADT.read(&id, 4);
WMOInstance inst(ADT, WmoInstanceNames[id].c_str(), map_num, tileX, tileY, dirfile);
WMOInstance inst(ADT, WmoInstanceNames[id].c_str(), map_num, tileX, tileY, originalMapId, dirfile, dirfileCache);
}
WmoInstanceNames.clear();
@@ -204,7 +211,37 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
return true;
}
bool ADTFile::initFromCache(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId)
{
if (dirfileCache->empty())
return true;
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE* dirfile = fopen(dirname.c_str(), "ab");
if (!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
for (ADTOutputCache const& cached : *dirfileCache)
{
fwrite(&map_num, sizeof(uint32), 1, dirfile);
fwrite(&tileX, sizeof(uint32), 1, dirfile);
fwrite(&tileY, sizeof(uint32), 1, dirfile);
uint32 flags = cached.Flags;
if (map_num != originalMapId)
flags |= MOD_PARENT_SPAWN;
fwrite(&flags, sizeof(uint32), 1, dirfile);
fwrite(cached.Data.data(), cached.Data.size(), 1, dirfile);
}
fclose(dirfile);
return true;
}
ADTFile::~ADTFile()
{
ADT.close();
delete dirfileCache;
}

23
src/tools/vmap4_extractor/adtfile.h
View File

@@ -106,31 +106,28 @@ struct MapChunkHeader
uint32 effectId;
};
struct ADTOutputCache
{
uint32 Flags;
std::vector<uint8> Data;
};
class ADTFile
{
private:
//size_t mcnk_offsets[256], mcnk_sizes[256];
CASCFile ADT;
//mcell Mcell;
std::string Adtfilename;
bool cacheable;
std::vector<ADTOutputCache>* dirfileCache;
public:
ADTFile(char* filename);
ADTFile(char* filename, bool cache);
~ADTFile();
int nWMO;
int nMDX;
std::vector<std::string> WmoInstanceNames;
std::vector<std::string> ModelInstanceNames;
bool init(uint32 map_num, uint32 tileX, uint32 tileY);
//void LoadMapChunks();
//uint32 wmo_count;
/*
const mcell& Getmcell() const
{
return Mcell;
}
*/
bool init(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId);
bool initFromCache(uint32 map_num, uint32 tileX, uint32 tileY, uint32 originalMapId);
};
char const* GetPlainName(char const* FileName);

33
src/tools/vmap4_extractor/model.cpp
View File

@@ -19,6 +19,7 @@
#include "vmapexport.h"
#include "model.h"
#include "wmo.h"
#include "adtfile.h"
#include "cascfile.h"
#include <cassert>
#include <algorithm>
@@ -154,7 +155,7 @@ Vec3D fixCoordSystem2(Vec3D v)
return Vec3D(v.x, v.z, v.y);
}
ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE *pDirfile)
ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache)
: id(0), scale(0), flags(0)
{
float ff[3];
@@ -190,6 +191,8 @@ ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapI
uint32 tcflags = MOD_M2;
if (tileX == 65 && tileY == 65)
tcflags |= MOD_WORLDSPAWN;
if (mapID != originalMapId)
tcflags |= MOD_PARENT_SPAWN;
//write mapID, tileX, tileY, Flags, ID, Pos, Rot, Scale, name
fwrite(&mapID, sizeof(uint32), 1, pDirfile);
@@ -205,6 +208,34 @@ ModelInstance::ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapI
fwrite(&nlen, sizeof(uint32), 1, pDirfile);
fwrite(ModelInstName, sizeof(char), nlen, pDirfile);
if (dirfileCache)
{
dirfileCache->emplace_back();
ADTOutputCache& cacheModelData = dirfileCache->back();
cacheModelData.Flags = tcflags & ~MOD_PARENT_SPAWN;
cacheModelData.Data.resize(
sizeof(uint16) + // adtId
sizeof(uint32) + // id
sizeof(float) * 3 + // pos
sizeof(float) * 3 + // rot
sizeof(float) + // sc
sizeof(uint32) + // nlen
nlen); // ModelInstName
uint8* cacheData = cacheModelData.Data.data();
#define CACHE_WRITE(value, size, count, dest) memcpy(dest, value, size * count); dest += size * count;
CACHE_WRITE(&adtId, sizeof(uint16), 1, cacheData);
CACHE_WRITE(&id, sizeof(uint32), 1, cacheData);
CACHE_WRITE(&pos, sizeof(float), 3, cacheData);
CACHE_WRITE(&rot, sizeof(float), 3, cacheData);
CACHE_WRITE(&sc, sizeof(float), 1, cacheData);
CACHE_WRITE(&nlen, sizeof(uint32), 1, cacheData);
CACHE_WRITE(ModelInstName, sizeof(char), nlen, cacheData);
#undef CACHE_WRITE
}
/* int realx1 = (int) ((float) pos.x / 533.333333f);
int realy1 = (int) ((float) pos.z / 533.333333f);
int realx2 = (int) ((float) pos.x / 533.333333f);

3
src/tools/vmap4_extractor/model.h
View File

@@ -24,6 +24,7 @@
#include <vector>
class CASCFile;
struct ADTOutputCache;
Vec3D fixCoordSystem(Vec3D v);
@@ -59,7 +60,7 @@ public:
float sc;
ModelInstance() : id(0), scale(0), flags(0), sc(0.0f) {}
ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile);
ModelInstance(CASCFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache);
};

93
src/tools/vmap4_extractor/vmapexport.cpp
View File

@@ -33,6 +33,7 @@
#include <list>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstdio>
#include <cerrno>
@@ -54,14 +55,14 @@
CASC::StorageHandle CascStorage;
typedef struct
struct map_info
{
char name[64];
unsigned int id;
}map_id;
int32 parent_id;
};
std::vector<map_id> map_ids;
uint32 map_count;
std::map<uint32, map_info> map_ids;
std::unordered_set<uint32> maps_that_are_parents;
boost::filesystem::path input_path;
bool preciseVectorData = false;
@@ -108,7 +109,7 @@ struct MapLoadInfo
//static const char * szWorkDirMaps = ".\\Maps";
const char* szWorkDirWmo = "./Buildings";
const char* szRawVMAPMagic = "VMAP045";
const char* szRawVMAPMagic = "VMAP046";
#define CASC_LOCALES_COUNT 17
char const* CascLocaleNames[CASC_LOCALES_COUNT] =
@@ -274,26 +275,49 @@ bool ExtractSingleWmo(std::string& fname)
void ParsMapFiles()
{
char fn[512];
//char id_filename[64];
char id[10];
for (unsigned int i = 0; i < map_ids.size(); ++i)
std::unordered_map<uint32, WDTFile> wdts;
auto getWDT = [&wdts](uint32 mapId) -> WDTFile*
{
sprintf(id, "%04u", map_ids[i].id);
sprintf(fn,"World\\Maps\\%s\\%s.wdt", map_ids[i].name, map_ids[i].name);
WDTFile WDT(fn,map_ids[i].name);
if(WDT.init(id, map_ids[i].id))
auto itr = wdts.find(mapId);
if (itr == wdts.end())
{
printf("Processing Map %u\n[", map_ids[i].id);
for (int x=0; x<64; ++x)
char fn[512];
char* name = map_ids[mapId].name;
sprintf(fn, "World\\Maps\\%s\\%s.wdt", name, name);
itr = wdts.emplace(std::piecewise_construct, std::forward_as_tuple(mapId), std::forward_as_tuple(fn, name, maps_that_are_parents.count(mapId) > 0)).first;
if (!itr->second.init(mapId))
{
for (int y=0; y<64; ++y)
wdts.erase(itr);
return nullptr;
}
}
return &itr->second;
};
for (auto itr = map_ids.begin(); itr != map_ids.end(); ++itr)
{
if (WDTFile* WDT = getWDT(itr->first))
{
WDTFile* parentWDT = itr->second.parent_id >= 0 ? getWDT(itr->second.parent_id) : nullptr;
printf("Processing Map %u\n[", itr->first);
for (int32 x = 0; x < 64; ++x)
{
for (int32 y = 0; y < 64; ++y)
{
if (ADTFile *ADT = WDT.GetMap(x,y))
bool success = false;
if (ADTFile* ADT = WDT->GetMap(x, y))
{
//sprintf(id_filename,"%02u %02u %04u",x,y,map_ids[i].id);//!!!!!!!!!
ADT->init(map_ids[i].id, x, y);
delete ADT;
success = ADT->init(itr->first, x, y, itr->first);
WDT->FreeADT(ADT);
}
if (!success && parentWDT)
{
if (ADTFile* ADT = parentWDT->GetMap(x, y))
{
ADT->init(itr->first, x, y, itr->second.parent_id);
parentWDT->FreeADT(ADT);
}
}
}
printf("#");
@@ -398,7 +422,7 @@ int main(int argc, char ** argv)
Trinity::Banner::Show("VMAP data extractor", [](char const* text) { printf("%s\n", text); }, nullptr);
bool success = true;
const char *versionString = "V4.03 2015_05";
const char *versionString = "V4.06 2018_02";
// Use command line arguments, when some
if (!processArgv(argc, argv, versionString))
@@ -480,36 +504,35 @@ int main(int argc, char ** argv)
exit(1);
}
map_ids.resize(db2.GetRecordCount());
std::unordered_map<uint32, uint32> idToIndex;
for (uint32 x = 0; x < db2.GetRecordCount(); ++x)
{
DB2Record record = db2.GetRecord(x);
map_ids[x].id = record.GetId();
map_info& m = map_ids[record.GetId()];
const char* map_name = record.GetString("Directory");
size_t max_map_name_length = sizeof(map_ids[x].name);
size_t max_map_name_length = sizeof(m.name);
if (strlen(map_name) >= max_map_name_length)
{
printf("Fatal error: Map name too long!\n");
exit(1);
}
strncpy(map_ids[x].name, map_name, max_map_name_length);
map_ids[x].name[max_map_name_length - 1] = '\0';
idToIndex[map_ids[x].id] = x;
strncpy(m.name, map_name, max_map_name_length);
m.name[max_map_name_length - 1] = '\0';
m.parent_id = int16(record.GetUInt16("ParentMapID"));
if (m.parent_id >= 0)
maps_that_are_parents.insert(m.parent_id);
}
for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x)
{
DB2RecordCopy copy = db2.GetRecordCopy(x);
auto itr = idToIndex.find(copy.SourceRowId);
if (itr != idToIndex.end())
auto itr = map_ids.find(copy.SourceRowId);
if (itr != map_ids.end())
{
map_id id;
id.id = copy.NewRowId;
strcpy(id.name, map_ids[itr->second].name);
map_ids.push_back(id);
map_info& id = map_ids[copy.NewRowId];
strcpy(id.name, itr->second.name);
id.parent_id = itr->second.parent_id;
}
}

5
src/tools/vmap4_extractor/vmapexport.h
View File

@@ -24,8 +24,9 @@
enum ModelFlags
{
MOD_M2 = 1,
MOD_WORLDSPAWN = 1<<1,
MOD_HAS_BOUND = 1<<2
MOD_WORLDSPAWN = 1 << 1,
MOD_HAS_BOUND = 1 << 2,
MOD_PARENT_SPAWN = 1 << 3
};
extern const char * szWorkDirWmo;

75
src/tools/vmap4_extractor/wdtfile.cpp
View File

@@ -19,6 +19,7 @@
#include "vmapexport.h"
#include "wdtfile.h"
#include "adtfile.h"
#include "Common.h"
#include <cstdio>
char * wdtGetPlainName(char * FileName)
@@ -32,40 +33,45 @@ char * wdtGetPlainName(char * FileName)
extern CASC::StorageHandle CascStorage;
WDTFile::WDTFile(char* file_name, char* file_name1):WDT(CascStorage, file_name), gnWMO(0)
WDTFile::WDTFile(char const* storagePath, std::string mapName, bool cache)
: _file(CascStorage, storagePath), _mapName(std::move(mapName))
{
filename.append(file_name1,strlen(file_name1));
if (cache)
{
_adtCache = Trinity::make_unique<ADTCache>();
memset(_adtCache->file, 0, sizeof(_adtCache->file));
}
else
_adtCache = nullptr;
}
bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
WDTFile::~WDTFile() = default;
bool WDTFile::init(uint32 mapId)
{
if (WDT.isEof())
{
//printf("Can't find WDT file.\n");
if (_file.isEof())
return false;
}
char fourcc[5];
uint32 size;
std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
FILE *dirfile;
dirfile = fopen(dirname.c_str(), "ab");
if(!dirfile)
FILE* dirfile = fopen(dirname.c_str(), "ab");
if (!dirfile)
{
printf("Can't open dirfile!'%s'\n", dirname.c_str());
return false;
}
while (!WDT.isEof())
while (!_file.isEof())
{
WDT.read(fourcc,4);
WDT.read(&size, 4);
_file.read(fourcc,4);
_file.read(&size, 4);
flipcc(fourcc);
fourcc[4] = 0;
size_t nextpos = WDT.getPos() + size;
size_t nextpos = _file.getPos() + size;
if (!strcmp(fourcc,"MAIN"))
{
@@ -76,7 +82,7 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
if (size)
{
char *buf = new char[size];
WDT.read(buf, size);
_file.read(buf, size);
char *p = buf;
while (p < buf + size)
{
@@ -86,7 +92,7 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
FixNameCase(s, strlen(s));
FixNameSpaces(s, strlen(s));
p = p + strlen(p) + 1;
gWmoInstansName.push_back(s);
_wmoNames.push_back(s);
ExtractSingleWmo(path);
}
@@ -98,36 +104,45 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID)
// global wmo instance data
if (size)
{
gnWMO = (int)size / 64;
int32 gnWMO = (int)size / 64;
for (int i = 0; i < gnWMO; ++i)
{
int id;
WDT.read(&id, 4);
WMOInstance inst(WDT, gWmoInstansName[id].c_str(), mapID, 65, 65, dirfile);
_file.read(&id, 4);
WMOInstance inst(_file, _wmoNames[id].c_str(), mapId, 65, 65, mapId, dirfile, nullptr);
}
}
}
WDT.seek((int)nextpos);
_file.seek((int)nextpos);
}
WDT.close();
_file.close();
fclose(dirfile);
return true;
}
WDTFile::~WDTFile(void)
ADTFile* WDTFile::GetMap(int32 x, int32 y)
{
WDT.close();
}
if (!(x >= 0 && y >= 0 && x < 64 && y < 64))
return nullptr;
ADTFile* WDTFile::GetMap(int x, int z)
{
if(!(x>=0 && z >= 0 && x<64 && z<64))
return NULL;
if (_adtCache && _adtCache->file[x][y])
return _adtCache->file[x][y].get();
char name[512];
sprintf(name,"World\\Maps\\%s\\%s_%d_%d_obj0.adt", filename.c_str(), filename.c_str(), x, z);
return new ADTFile(name);
sprintf(name, "World\\Maps\\%s\\%s_%d_%d_obj0.adt", _mapName.c_str(), _mapName.c_str(), x, y);
ADTFile* adt = new ADTFile(name, _adtCache != nullptr);
if (_adtCache)
_adtCache->file[x][y].reset(adt);
return adt;
}
void WDTFile::FreeADT(ADTFile* adt)
{
if (_adtCache)
return;
delete adt;
}

25
src/tools/vmap4_extractor/wdtfile.h
View File

@@ -21,6 +21,7 @@
#include "cascfile.h"
#include "wmo.h"
#include <memory>
#include <string>
#include <vector>
@@ -28,18 +29,22 @@ class ADTFile;
class WDTFile
{
private:
CASCFile WDT;
std::string filename;
public:
WDTFile(char* file_name, char* file_name1);
~WDTFile(void);
bool init(char* map_id, unsigned int mapID);
WDTFile(char const* storagePath, std::string mapName, bool cache);
~WDTFile();
bool init(uint32 mapId);
std::vector<std::string> gWmoInstansName;
int gnWMO;
ADTFile* GetMap(int x, int z);
ADTFile* GetMap(int32 x, int32 y);
void FreeADT(ADTFile* adt);
private:
CASCFile _file;
std::string _mapName;
std::vector<std::string> _wmoNames;
struct ADTCache
{
std::unique_ptr<ADTFile> file[64][64];
};
std::unique_ptr<ADTCache> _adtCache;
};
#endif

43
src/tools/vmap4_extractor/wmo.cpp
View File

@@ -18,6 +18,7 @@
#include "vmapexport.h"
#include "wmo.h"
#include "adtfile.h"
#include "vec3d.h"
#include <cstdio>
#include <cstdlib>
@@ -514,7 +515,7 @@ WMOGroup::~WMOGroup()
delete [] LiquBytes;
}
WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile)
WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache)
: currx(0), curry(0), wmo(NULL), doodadset(0), pos(), indx(0), id(0)
{
float ff[3];
@@ -578,7 +579,11 @@ WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uin
float scale = 1.0f;
uint32 flags = MOD_HAS_BOUND;
if(tileX == 65 && tileY == 65) flags |= MOD_WORLDSPAWN;
if (tileX == 65 && tileY == 65)
flags |= MOD_WORLDSPAWN;
if (mapID != originalMapId)
flags |= MOD_PARENT_SPAWN;
//write mapID, tileX, tileY, Flags, ID, Pos, Rot, Scale, Bound_lo, Bound_hi, name
fwrite(&mapID, sizeof(uint32), 1, pDirfile);
fwrite(&tileX, sizeof(uint32), 1, pDirfile);
@@ -591,10 +596,42 @@ WMOInstance::WMOInstance(CASCFile& f, char const* WmoInstName, uint32 mapID, uin
fwrite(&scale, sizeof(float), 1, pDirfile);
fwrite(&pos2, sizeof(float), 3, pDirfile);
fwrite(&pos3, sizeof(float), 3, pDirfile);
uint32 nlen=strlen(WmoInstName);
uint32 nlen = strlen(WmoInstName);
fwrite(&nlen, sizeof(uint32), 1, pDirfile);
fwrite(WmoInstName, sizeof(char), nlen, pDirfile);
if (dirfileCache)
{
dirfileCache->emplace_back();
ADTOutputCache& cacheModelData = dirfileCache->back();
cacheModelData.Flags = flags & ~MOD_PARENT_SPAWN;
cacheModelData.Data.resize(
sizeof(uint16) + // adtId
sizeof(uint32) + // id
sizeof(float) * 3 + // pos
sizeof(float) * 3 + // rot
sizeof(float) + // scale
sizeof(float) * 3 + // pos2
sizeof(float) * 3 + // pos3
sizeof(uint32) + // nlen
nlen); // WmoInstName
uint8* cacheData = cacheModelData.Data.data();
#define CACHE_WRITE(value, size, count, dest) memcpy(dest, value, size * count); dest += size * count;
CACHE_WRITE(&adtId, sizeof(uint16), 1, cacheData);
CACHE_WRITE(&id, sizeof(uint32), 1, cacheData);
CACHE_WRITE(&pos, sizeof(float), 3, cacheData);
CACHE_WRITE(&rot, sizeof(float), 3, cacheData);
CACHE_WRITE(&scale, sizeof(float), 1, cacheData);
CACHE_WRITE(&pos2, sizeof(float), 3, cacheData);
CACHE_WRITE(&pos3, sizeof(float), 3, cacheData);
CACHE_WRITE(&nlen, sizeof(uint32), 1, cacheData);
CACHE_WRITE(WmoInstName, sizeof(char), nlen, cacheData);
#undef CACHE_WRITE
}
/* fprintf(pDirfile,"%s/%s %f,%f,%f_%f,%f,%f 1.0 %d %d %d,%d %d\n",
MapName,
WmoInstName,

3
src/tools/vmap4_extractor/wmo.h
View File

@@ -43,6 +43,7 @@ enum MopyFlags
class WMOInstance;
class WMOManager;
class CASCFile;
struct ADTOutputCache;
/* for whatever reason a certain company just can't stick to one coordinate system... */
static inline Vec3D fixCoords(const Vec3D &v){ return Vec3D(v.z, v.x, v.y); }
@@ -138,7 +139,7 @@ public:
Vec3D pos2, pos3, rot;
uint32 indx, id;
WMOInstance(CASCFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile);
WMOInstance(CASCFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector<ADTOutputCache>* dirfileCache);
};
#endif