From 4bbdce57e200ecb703bd5d40dc4529c7402e47b1 Mon Sep 17 00:00:00 2001 From: Ovahlord Date: Fri, 9 Mar 2018 17:51:46 +0100 Subject: [PATCH] Core/VMaps: Implement loading phased tiles --- .../Collision/Management/IVMapManager.h | 1 + .../Collision/Management/VMapManager2.cpp | 82 +++++++++++--- .../Collision/Management/VMapManager2.h | 12 ++- src/common/Collision/Maps/MapTree.cpp | 95 +++++++++++----- src/common/Collision/Maps/MapTree.h | 16 ++- src/common/Collision/Maps/TileAssembler.cpp | 35 +++--- src/common/Collision/Maps/TileAssembler.h | 8 +- src/common/Collision/Models/ModelInstance.h | 5 +- src/common/Collision/VMapDefinitions.h | 4 +- src/server/game/World/World.cpp | 8 +- src/tools/mmaps_generator/MapBuilder.cpp | 2 +- src/tools/vmap4_extractor/adtfile.cpp | 49 +++++++-- src/tools/vmap4_extractor/adtfile.h | 23 ++-- src/tools/vmap4_extractor/model.cpp | 33 +++++- src/tools/vmap4_extractor/model.h | 3 +- src/tools/vmap4_extractor/vmapexport.cpp | 102 +++++++++++------- src/tools/vmap4_extractor/vmapexport.h | 5 +- src/tools/vmap4_extractor/wdtfile.cpp | 36 +++++-- src/tools/vmap4_extractor/wdtfile.h | 10 +- src/tools/vmap4_extractor/wmo.cpp | 43 +++++++- src/tools/vmap4_extractor/wmo.h | 3 +- 21 files changed, 433 insertions(+), 142 deletions(-) diff --git a/src/common/Collision/Management/IVMapManager.h b/src/common/Collision/Management/IVMapManager.h index 3f5282c0e37..2a633d32542 100644 --- a/src/common/Collision/Management/IVMapManager.h +++ b/src/common/Collision/Management/IVMapManager.h @@ -127,6 +127,7 @@ namespace VMAP // get both area + liquid data in a single vmap lookup virtual void getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, uint8 reqLiquidType, AreaAndLiquidData& data) const=0; + virtual int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const = 0; }; } diff --git a/src/common/Collision/Management/VMapManager2.cpp b/src/common/Collision/Management/VMapManager2.cpp index 94f8f8beb4b..29ce04ae2fb 100644 --- a/src/common/Collision/Management/VMapManager2.cpp +++ b/src/common/Collision/Management/VMapManager2.cpp @@ -52,11 +52,17 @@ namespace VMAP } } - void VMapManager2::InitializeThreadUnsafe(const std::vector& mapIds) + void VMapManager2::InitializeThreadUnsafe(std::unordered_map> 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> const& mapId : mapData) + { + iInstanceMapTrees.insert(InstanceTreeMap::value_type(mapId.first, nullptr)); + for (uint32 childMapId : mapId.second) + iParentMapData[childMapId] = mapId.first; + } + thread_safe_environment = false; } @@ -85,10 +91,16 @@ namespace VMAP int VMapManager2::loadMap(const char* basePath, unsigned int mapId, int x, int y) { int result = VMAP_LOAD_RESULT_IGNORED; - if (isMapLoadingEnabled()) { if (_loadMap(mapId, basePath, x, y)) + { result = VMAP_LOAD_RESULT_OK; + auto childMaps = iChildMapData.find(mapId); + if (childMaps != iChildMapData.end()) + for (uint32 childMapId : childMaps->second) + if (!_loadMap(childMapId, basePath, x, y)) + result = VMAP_LOAD_RESULT_ERROR; + } else result = VMAP_LOAD_RESULT_ERROR; } @@ -134,7 +146,21 @@ namespace VMAP return instanceTree->second->LoadMapTile(tileX, tileY, this); } - void VMapManager2::unloadMap(unsigned int mapId) + void VMapManager2::_unloadMap(uint32 mapId, int x, int y) + { + InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId); + if (instanceTree != iInstanceMapTrees.end() && instanceTree->second) + { + instanceTree->second->UnloadMapTile(x, y, this); + if (instanceTree->second->numLoadedTiles() == 0) + { + delete instanceTree->second; + instanceTree->second = nullptr; + } + } + } + + void VMapManager2::_unloadMap(uint32 mapId) { InstanceTreeMap::iterator instanceTree = iInstanceMapTrees.find(mapId); if (instanceTree != iInstanceMapTrees.end() && instanceTree->second) @@ -150,16 +176,22 @@ namespace VMAP void VMapManager2::unloadMap(unsigned int mapId, int x, int y) { - 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; - } - } + auto childMaps = iChildMapData.find(mapId); + if (childMaps != iChildMapData.end()) + for (uint32 childMapId : childMaps->second) + _unloadMap(childMapId, x, y); + + _unloadMap(mapId, x, y); + } + + void VMapManager2::unloadMap(unsigned int mapId) + { + auto childMaps = iChildMapData.find(mapId); + if (childMaps != iChildMapData.end()) + for (uint32 childMapId : childMaps->second) + _unloadMap(childMapId); + + _unloadMap(mapId); } bool VMapManager2::isInLineOfSight(unsigned int mapId, float x1, float y1, float z1, float x2, float y2, float z2, ModelIgnoreFlags ignoreFlags) @@ -312,6 +344,15 @@ namespace VMAP } } + 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::max(); + } + WorldModel* VMapManager2::acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags/* Only used when creating the model */) { //! Critical section, thread safe access to iLoadedModelFiles @@ -359,7 +400,7 @@ namespace VMAP LoadResult 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) @@ -367,4 +408,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 diff --git a/src/common/Collision/Management/VMapManager2.h b/src/common/Collision/Management/VMapManager2.h index a45454291c4..a58e34cfa78 100644 --- a/src/common/Collision/Management/VMapManager2.h +++ b/src/common/Collision/Management/VMapManager2.h @@ -81,12 +81,15 @@ namespace VMAP // Tree to check collision ModelFileMap iLoadedModelFiles; InstanceTreeMap iInstanceMapTrees; + std::unordered_map> iChildMapData; + std::unordered_map 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); */ + void _unloadMap(uint32 mapId, int x, int y); + void _unloadMap(uint32 mapId); static uint32 GetLiquidFlagsDummy(uint32) { return 0; } static bool IsVMAPDisabledForDummy(uint32 /*entry*/, uint8 /*flags*/) { return false; } @@ -101,9 +104,10 @@ namespace VMAP VMapManager2(); ~VMapManager2(void); - void InitializeThreadUnsafe(const std::vector& mapIds); + void InitializeThreadUnsafe(std::unordered_map> const& mapData); int loadMap(const char* pBasePath, unsigned int mapId, int x, int y) override; + void unloadMap(unsigned int mapId, int x, int y) override; void unloadMap(unsigned int mapId) override; @@ -120,6 +124,8 @@ namespace VMAP bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 reqLiquidType, float& level, float& floor, uint32& type) const override; void getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, uint8 reqLiquidType, AreaAndLiquidData& data) const override; + int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const override; + WorldModel* acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags = 0); void releaseModelInstance(const std::string& filename); @@ -132,6 +138,8 @@ namespace VMAP void getInstanceMapTree(InstanceTreeMap &instanceMapTree); + int32 getParentMapId(uint32 mapId) const; + typedef uint32(*GetLiquidFlagsFn)(uint32 liquidType); GetLiquidFlagsFn GetLiquidFlagsPtr; diff --git a/src/common/Collision/Maps/MapTree.cpp b/src/common/Collision/Maps/MapTree.cpp index 5f85a08aaef..e22cfe3f9be 100644 --- a/src/common/Collision/Maps/MapTree.cpp +++ b/src/common/Collision/Maps/MapTree.cpp @@ -236,8 +236,28 @@ 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; + } + //========================================================= - LoadResult StaticMapTree::CanLoadMap(const std::string &vmapPath, uint32 mapID, uint32 tileX, uint32 tileY) + LoadResult 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) result = LoadResult::FileNotFound; 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(); } //========================================================= @@ -359,22 +395,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; isecond; 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()); continue; @@ -414,7 +449,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; ireleaseModelInstance(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 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::max(); + for (std::pair const& primaryTile : iLoadedPrimaryTiles) + minDistance = std::min(minDistance, (primaryTile.first - x) * (primaryTile.first - x) + (primaryTile.second - y) * (primaryTile.second - y)); + + return minDistance; + } } diff --git a/src/common/Collision/Maps/MapTree.h b/src/common/Collision/Maps/MapTree.h index 0c99534dda9..8f9fdf1a6c7 100644 --- a/src/common/Collision/Maps/MapTree.h +++ b/src/common/Collision/Maps/MapTree.h @@ -51,23 +51,33 @@ namespace VMAP BIH iTree; ModelInstance* iTreeValues; // the tree entries uint32 iNTreeValues; + std::unordered_map 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> iLoadedPrimaryTiles; // stores 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, ModelIgnoreFlags ignoreFlags) 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 LoadResult 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 LoadResult CanLoadMap(const std::string &basePath, uint32 mapID, uint32 tileX, uint32 tileY, VMapManager2* vm); StaticMapTree(uint32 mapID, const std::string &basePath); ~StaticMapTree(); @@ -86,6 +96,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; diff --git a/src/common/Collision/Maps/TileAssembler.cpp b/src/common/Collision/Maps/TileAssembler.cpp index 84e759383fb..00ac2b263f1 100644 --- a/src/common/Collision/Maps/TileAssembler.cpp +++ b/src/common/Collision/Maps/TileAssembler.cpp @@ -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,10 +110,6 @@ namespace VMAP } // ===> possibly move this code to StaticMapTree class - std::map modelNodeIdx; - for (uint32 i=0; i(mapSpawns[i]->ID, i)); - // write map tree file std::stringstream mapfilename; mapfilename << iDestDir << '/' << std::setfill('0') << std::setw(3) << map_iter->first << ".vmtree"; @@ -139,7 +135,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 +157,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 +179,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::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 @@ -238,9 +241,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(spawn.ID, spawn)); - current->TileEntries.insert(pair(StaticMapTree::packTileID(tileX, tileY), spawn.ID)); + current->TileEntries.insert(pair(StaticMapTree::packTileID(tileX, tileY), TileSpawn{ spawn.ID, spawn.flags })); } bool success = (ferror(dirf) == 0); fclose(dirf); diff --git a/src/common/Collision/Maps/TileAssembler.h b/src/common/Collision/Maps/TileAssembler.h index f370bb638ba..8c3b3f5b88d 100644 --- a/src/common/Collision/Maps/TileAssembler.h +++ b/src/common/Collision/Maps/TileAssembler.h @@ -52,8 +52,14 @@ namespace VMAP void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; } }; + struct TileSpawn + { + uint32 Id; + uint32 Flags; + }; + typedef std::map UniqueEntryMap; - typedef std::multimap TileMap; + typedef std::multimap TileMap; struct TC_COMMON_API MapSpawns { diff --git a/src/common/Collision/Models/ModelInstance.h b/src/common/Collision/Models/ModelInstance.h index 80118b9a9c2..1a9a2ab3fff 100644 --- a/src/common/Collision/Models/ModelInstance.h +++ b/src/common/Collision/Models/ModelInstance.h @@ -36,8 +36,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 diff --git a/src/common/Collision/VMapDefinitions.h b/src/common/Collision/VMapDefinitions.h index 22885ec3855..5410eb2130c 100644 --- a/src/common/Collision/VMapDefinitions.h +++ b/src/common/Collision/VMapDefinitions.h @@ -25,8 +25,8 @@ namespace VMAP { - const char VMAP_MAGIC[] = "VMAP_4.4"; - const char RAW_VMAP_MAGIC[] = "VMAP044"; // used in extracted vmap files with raw data + const char VMAP_MAGIC[] = "VMAP_4.5"; + const char RAW_VMAP_MAGIC[] = "VMAP045"; // used in extracted vmap files with raw data const char GAMEOBJECT_MODELS[] = "GameObjectModels.dtree"; // defined in TileAssembler.cpp currently... diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp index b364a6136d3..cae28cae6f8 100644 --- a/src/server/game/World/World.cpp +++ b/src/server/game/World/World.cpp @@ -1503,11 +1503,17 @@ void World::SetInitialWorldSettings() LoadM2Cameras(m_dataPath); std::vector mapIds; + std::unordered_map> mapData; for (MapEntry const* mapEntry : sMapStore) + { mapIds.push_back(mapEntry->MapID); + mapData.emplace(std::piecewise_construct, std::forward_as_tuple(mapEntry->MapID), std::forward_as_tuple()); + if (mapEntry->rootPhaseMap != -1) + mapData[mapEntry->rootPhaseMap].push_back(mapEntry->MapID); + } if (VMAP::VMapManager2* vmmgr2 = dynamic_cast(VMAP::VMapFactory::createOrGetVMapManager())) - vmmgr2->InitializeThreadUnsafe(mapIds); + vmmgr2->InitializeThreadUnsafe(mapData); MMAP::MMapManager* mmmgr = MMAP::MMapFactory::createOrGetMMapManager(); mmmgr->InitializeThreadUnsafe(mapIds); diff --git a/src/tools/mmaps_generator/MapBuilder.cpp b/src/tools/mmaps_generator/MapBuilder.cpp index 5e6b12d71ab..56e8ba318fd 100644 --- a/src/tools/mmaps_generator/MapBuilder.cpp +++ b/src/tools/mmaps_generator/MapBuilder.cpp @@ -214,7 +214,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(); }); diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp index d6a0a642bc0..516fcf3a86b 100644 --- a/src/tools/vmap4_extractor/adtfile.cpp +++ b/src/tools/vmap4_extractor/adtfile.cpp @@ -79,13 +79,18 @@ char* GetExtension(char* FileName) extern HANDLE WorldMpq; -ADTFile::ADTFile(char* filename) : ADT(WorldMpq, filename, false) +ADTFile::ADTFile(char* filename, bool cache) : ADT(WorldMpq, filename, false) { 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; @@ -107,14 +112,16 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY) //printf("yMap = %s\n", yMap.c_str()); 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(); + while (!ADT.isEof()) { char fourcc[5]; @@ -189,7 +196,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); } delete[] ModelInstanceNames; ModelInstanceNames = NULL; @@ -204,7 +211,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); } delete[] WmoInstanceNames; @@ -221,7 +228,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; } diff --git a/src/tools/vmap4_extractor/adtfile.h b/src/tools/vmap4_extractor/adtfile.h index 6567254108a..f1f42f3fd4e 100644 --- a/src/tools/vmap4_extractor/adtfile.h +++ b/src/tools/vmap4_extractor/adtfile.h @@ -106,31 +106,28 @@ struct MapChunkHeader uint32 effectId; }; +struct ADTOutputCache +{ + uint32 Flags; + std::vector Data; +}; class ADTFile { private: - //size_t mcnk_offsets[256], mcnk_sizes[256]; MPQFile ADT; - //mcell Mcell; std::string Adtfilename; + bool cacheable; + std::vector* dirfileCache; public: - ADTFile(char* filename); + ADTFile(char* filename, bool cache); ~ADTFile(); int nWMO; int nMDX; std::string* WmoInstanceNames; 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); diff --git a/src/tools/vmap4_extractor/model.cpp b/src/tools/vmap4_extractor/model.cpp index 204bca77cad..d797a28a61f 100644 --- a/src/tools/vmap4_extractor/model.cpp +++ b/src/tools/vmap4_extractor/model.cpp @@ -19,6 +19,7 @@ #include "vmapexport.h" #include "model.h" #include "wmo.h" +#include "adtfile.h" #include "mpqfile.h" #include #include @@ -144,7 +145,7 @@ Vec3D fixCoordSystem2(Vec3D v) return Vec3D(v.x, v.z, v.y); } -ModelInstance::ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE *pDirfile) +ModelInstance::ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector* dirfileCache) : id(0), scale(0), flags(0) { float ff[3]; @@ -180,6 +181,8 @@ ModelInstance::ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID uint32 flags = MOD_M2; if (tileX == 65 && tileY == 65) flags |= MOD_WORLDSPAWN; + if (mapID != originalMapId) + flags |= MOD_PARENT_SPAWN; //write mapID, tileX, tileY, Flags, ID, Pos, Rot, Scale, name fwrite(&mapID, sizeof(uint32), 1, pDirfile); @@ -195,6 +198,34 @@ ModelInstance::ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID fwrite(&nlen, sizeof(uint32), 1, pDirfile); fwrite(ModelInstName, 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) + // 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); diff --git a/src/tools/vmap4_extractor/model.h b/src/tools/vmap4_extractor/model.h index fea5cb3f7a9..283279ea54a 100644 --- a/src/tools/vmap4_extractor/model.h +++ b/src/tools/vmap4_extractor/model.h @@ -24,6 +24,7 @@ #include class MPQFile; +struct ADTOutputCache; Vec3D fixCoordSystem(Vec3D v); @@ -59,7 +60,7 @@ public: float sc; ModelInstance() : id(0), scale(0), flags(0), sc(0.0f) {} - ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile); + ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector* dirfileCache); }; diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp index 33630d635b5..59a28188eab 100644 --- a/src/tools/vmap4_extractor/vmapexport.cpp +++ b/src/tools/vmap4_extractor/vmapexport.cpp @@ -22,6 +22,8 @@ #include #include #include +#include +#include #ifdef _WIN32 #include @@ -103,15 +105,15 @@ TCHAR const* LocalesT[LOCALES_COUNT] = _T("itIT"), }; -typedef struct +struct map_info { char name[64]; - unsigned int id; -}map_id; + int32 parent_id; +}; -map_id * map_ids; +std::map map_ids; +std::unordered_set maps_that_are_parents; uint16 *LiqType = 0; -uint32 map_count; char output_path[128]="."; char input_path[1024]="."; bool preciseVectorData = false; @@ -120,7 +122,7 @@ bool preciseVectorData = false; //static const char * szWorkDirMaps = ".\\Maps"; const char* szWorkDirWmo = "./Buildings"; -const char* szRawVMAPMagic = "VMAP044"; +const char* szRawVMAPMagic = "VMAP045"; bool LoadLocaleMPQFile(int locale) { @@ -389,26 +391,51 @@ bool ExtractSingleWmo(std::string& fname) void ParsMapFiles() { - char fn[512]; - //char id_filename[64]; - char id[10]; - for (unsigned int i=0; i wdts; + auto getWDT = [&wdts](uint32 mapId) -> WDTFile* { - sprintf(id,"%03u",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 id[10]; + char* name = map_ids[mapId].name; + sprintf(id, "%04u", itr->first); + 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(id, 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 (int x = 0; x < 64; ++x) + { + for (int 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 %03u",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("#"); @@ -507,7 +534,7 @@ bool processArgv(int argc, char ** argv, const char *versionString) int main(int argc, char ** argv) { bool success=true; - const char *versionString = "V4.00 2012_02"; + const char *versionString = "V4.05 2018_03"; // Use command line arguments, when some if (!processArgv(argc, argv, versionString)) @@ -564,39 +591,36 @@ int main(int argc, char ** argv) //map.dbc if (success) { - DBCFile * dbc = new DBCFile(LocaleMpq, "DBFilesClient\\Map.dbc"); + DBCFile* dbc = new DBCFile(LocaleMpq, "DBFilesClient\\Map.dbc"); if (!dbc->open()) { delete dbc; printf("FATAL ERROR: Map.dbc not found in data file.\n"); return 1; } - map_count=dbc->getRecordCount (); - map_ids=new map_id[map_count]; - for (unsigned int x=0;xgetRecord(x).getUInt(0); - const char* map_name = dbc->getRecord(x).getString(1); - size_t max_map_name_length = sizeof(map_ids[x].name); + for (uint32 x = 0; x < dbc->getRecordCount(); ++x) + { + map_info& m = map_ids[dbc->getRecord(x).getUInt(0)]; + + const char* map_name = dbc->getRecord(x).getString(6); + size_t max_map_name_length = sizeof(m.name); if (strlen(map_name) >= max_map_name_length) { - delete dbc; - delete[] map_ids; - printf("FATAL ERROR: Map name too long.\n"); - return 1; + printf("Fatal error: Map name too long!\n"); + exit(1); } - strncpy(map_ids[x].name, map_name, max_map_name_length); + strncpy(m.name, map_name, max_map_name_length); map_ids[x].name[max_map_name_length - 1] = '\0'; + m.parent_id = int16(dbc->getRecord(x).getUInt(19)); + if (m.parent_id >= 0) + maps_that_are_parents.insert(m.parent_id); + printf("Map - %s\n", map_ids[x].name); } - delete dbc; ParsMapFiles(); - delete [] map_ids; - //nError = ERROR_SUCCESS; - // Extract models, listed in GameObjectDisplayInfo.dbc ExtractGameobjectModels(); } diff --git a/src/tools/vmap4_extractor/vmapexport.h b/src/tools/vmap4_extractor/vmapexport.h index a73d259d52b..c798fb496ba 100644 --- a/src/tools/vmap4_extractor/vmapexport.h +++ b/src/tools/vmap4_extractor/vmapexport.h @@ -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; diff --git a/src/tools/vmap4_extractor/wdtfile.cpp b/src/tools/vmap4_extractor/wdtfile.cpp index 8948489a900..c75005a41a7 100644 --- a/src/tools/vmap4_extractor/wdtfile.cpp +++ b/src/tools/vmap4_extractor/wdtfile.cpp @@ -33,9 +33,16 @@ char * wdtGetPlainName(char * FileName) extern HANDLE WorldMpq; -WDTFile::WDTFile(char* file_name, char* file_name1):WDT(WorldMpq, file_name) +WDTFile::WDTFile(char* file_name, char* file_name1, bool cache):WDT(WorldMpq, file_name) { filename.append(file_name1,strlen(file_name1)); + if (cache) + { + adtCache = new ADTCache(); + memset(adtCache->file, 0, sizeof(adtCache->file)); + } + else + adtCache = nullptr; } bool WDTFile::init(char* /*map_id*/, unsigned int mapID) @@ -102,7 +109,7 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID) { int id; WDT.read(&id, 4); - WMOInstance inst(WDT,gWmoInstansName[id].c_str(), mapID, 65, 65, dirfile); + WMOInstance inst(WDT,gWmoInstansName[id].c_str(), mapID, 65, 65, mapID, dirfile, nullptr); } delete[] gWmoInstansName; @@ -120,15 +127,30 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID) WDTFile::~WDTFile(void) { WDT.close(); + delete adtCache; } -ADTFile* WDTFile::GetMap(int x, int z) +ADTFile* WDTFile::GetMap(int x, int y) { - if (!(x>=0 && z >= 0 && x<64 && z<64)) - return NULL; + if (!(x >= 0 && y >= 0 && x < 64 && y < 64)) + return nullptr; + + 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", filename.c_str(), filename.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; } diff --git a/src/tools/vmap4_extractor/wdtfile.h b/src/tools/vmap4_extractor/wdtfile.h index 49f10cf306c..98f4fc59338 100644 --- a/src/tools/vmap4_extractor/wdtfile.h +++ b/src/tools/vmap4_extractor/wdtfile.h @@ -21,17 +21,19 @@ #include "mpqfile.h" #include +#include class ADTFile; class WDTFile { public: - WDTFile(char* file_name, char* file_name1); + WDTFile(char* file_name, char* file_name1, bool cache); ~WDTFile(void); bool init(char* map_id, unsigned int mapID); - ADTFile* GetMap(int x, int z); + ADTFile* GetMap(int x, int y); + void FreeADT(ADTFile* adt); std::string* gWmoInstansName; int gnWMO; @@ -39,6 +41,10 @@ public: private: MPQFile WDT; std::string filename; + struct ADTCache + { + std::unique_ptr file[64][64]; + } *adtCache; }; #endif diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp index 2b0bee9417b..dbfe3a9c8f5 100644 --- a/src/tools/vmap4_extractor/wmo.cpp +++ b/src/tools/vmap4_extractor/wmo.cpp @@ -18,6 +18,7 @@ #include "vmapexport.h" #include "wmo.h" +#include "adtfile.h" #include "vec3d.h" #include @@ -485,7 +486,7 @@ WMOGroup::~WMOGroup() delete [] LiquBytes; } -WMOInstance::WMOInstance(MPQFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile) +WMOInstance::WMOInstance(MPQFile& f, char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector* dirfileCache) : currx(0), curry(0), wmo(NULL), doodadset(0), pos(), indx(0), id(0) { float ff[3]; @@ -549,7 +550,11 @@ WMOInstance::WMOInstance(MPQFile& f, char const* WmoInstName, uint32 mapID, uint 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); @@ -562,10 +567,42 @@ WMOInstance::WMOInstance(MPQFile& f, char const* WmoInstName, uint32 mapID, uint 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, diff --git a/src/tools/vmap4_extractor/wmo.h b/src/tools/vmap4_extractor/wmo.h index a5c4e71d93c..d85b2fd2af7 100644 --- a/src/tools/vmap4_extractor/wmo.h +++ b/src/tools/vmap4_extractor/wmo.h @@ -42,6 +42,7 @@ enum MopyFlags class WMOInstance; class WMOManager; class MPQFile; +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); } @@ -134,7 +135,7 @@ public: Vec3D pos2, pos3, rot; uint32 indx, id; - WMOInstance(MPQFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile); + WMOInstance(MPQFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, uint32 originalMapId, FILE* pDirfile, std::vector* dirfileCache); static void reset(); };