Tools/vmap_extractor: Move information about model type from spawns in vmap tiles to model file itself

16 files changed, 94 insertions, 84 deletions

diff --git a/src/common/Collision/Management/VMapManager2.cpp b/src/common/Collision/Management/VMapManager2.cpp
index 5ae50115486..78d5be2b79c 100644
--- a/src/common/Collision/Management/VMapManager2.cpp
+++ b/src/common/Collision/Management/VMapManager2.cpp
@@ -315,7 +315,7 @@ namespace VMAP
         }
     }
 
-    WorldModel* VMapManager2::acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags/* Only used when creating the model */)
+    WorldModel* VMapManager2::acquireModelInstance(std::string const& basepath, std::string const& filename)
     {
         //! Critical section, thread safe access to iLoadedModelFiles
         std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
@@ -333,7 +333,6 @@ namespace VMAP
             TC_LOG_DEBUG("maps", "VMapManager2: loading file '{}{}'", basepath, filename);
 
             worldmodel->getModel()->SetName(filename);
-            worldmodel->getModel()->Flags = flags;
 
             model = iLoadedModelFiles.insert(std::pair<std::string, ManagedModel*>(filename, worldmodel)).first;
         }
@@ -341,7 +340,7 @@ namespace VMAP
         return model->second->getModel();
     }
 
-    void VMapManager2::releaseModelInstance(const std::string &filename)
+    void VMapManager2::releaseModelInstance(std::string const& filename)
     {
         //! Critical section, thread safe access to iLoadedModelFiles
         std::lock_guard<std::mutex> lock(LoadedModelFilesLock);
diff --git a/src/common/Collision/Management/VMapManager2.h b/src/common/Collision/Management/VMapManager2.h
index b18d52ac042..3dda9c54cd2 100644
--- a/src/common/Collision/Management/VMapManager2.h
+++ b/src/common/Collision/Management/VMapManager2.h
@@ -107,8 +107,8 @@ namespace VMAP
             bool GetLiquidLevel(uint32 mapId, float x, float y, float z, uint8 reqLiquidType, float& level, float& floor, uint32& type, uint32& mogpFlags) const override;
             void getAreaAndLiquidData(uint32 mapId, float x, float y, float z, uint8 reqLiquidType, AreaAndLiquidData& data) const override;
 
-            WorldModel* acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags = 0);
-            void releaseModelInstance(const std::string& filename);
+            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
diff --git a/src/common/Collision/Maps/MapTree.cpp b/src/common/Collision/Maps/MapTree.cpp
index 0ff4dfff4b9..88eb9d2c6df 100644
--- a/src/common/Collision/Maps/MapTree.cpp
+++ b/src/common/Collision/Maps/MapTree.cpp
@@ -391,7 +391,7 @@ namespace VMAP
                 if (ModelSpawn::readFromFile(fileResult.File, spawn))
                 {
                     // acquire model instance
-                    WorldModel* model = vm->acquireModelInstance(iBasePath, spawn.name, spawn.flags);
+                    WorldModel* model = vm->acquireModelInstance(iBasePath, spawn.name);
                     if (!model)
                         TC_LOG_ERROR("misc", "StaticMapTree::LoadMapTile() : could not acquire WorldModel pointer [{}, {}]", tileX, tileY);
 
diff --git a/src/common/Collision/Models/GameObjectModel.cpp b/src/common/Collision/Models/GameObjectModel.cpp
index 946fe5b3e8b..363863f5759 100644
--- a/src/common/Collision/Models/GameObjectModel.cpp
+++ b/src/common/Collision/Models/GameObjectModel.cpp
@@ -32,12 +32,11 @@ using G3D::AABox;
 
 struct GameobjectModelData
 {
-    GameobjectModelData(char const* name_, uint32 nameLength, Vector3 const& lowBound, Vector3 const& highBound, bool isWmo_) :
-        bound(lowBound, highBound), name(name_, nameLength), isWmo(isWmo_) { }
+    GameobjectModelData(char const* name_, uint32 nameLength, Vector3 const& lowBound, Vector3 const& highBound) :
+        bound(lowBound, highBound), name(name_, nameLength) { }
 
     AABox bound;
     std::string name;
-    bool isWmo;
 };
 
 typedef std::unordered_map<uint32, GameobjectModelData> ModelList;
@@ -63,7 +62,6 @@ bool LoadGameObjectModelList(std::string const& dataPath)
     }
 
     uint32 name_length, displayId;
-    uint8 isWmo;
     char buff[500];
     while (true)
     {
@@ -72,8 +70,7 @@ bool LoadGameObjectModelList(std::string const& dataPath)
             if (feof(model_list_file.get()))  // EOF flag is only set after failed reading attempt
                 break;
 
-        if (fread(&isWmo, sizeof(uint8), 1, model_list_file.get()) != 1
-            || fread(&name_length, sizeof(uint32), 1, model_list_file.get()) != 1
+        if (fread(&name_length, sizeof(uint32), 1, model_list_file.get()) != 1
             || name_length >= sizeof(buff)
             || fread(&buff, sizeof(char), name_length, model_list_file.get()) != name_length
             || fread(&v1, sizeof(Vector3), 1, model_list_file.get()) != 1
@@ -89,7 +86,7 @@ bool LoadGameObjectModelList(std::string const& dataPath)
             continue;
         }
 
-        model_list.emplace(std::piecewise_construct, std::forward_as_tuple(displayId), std::forward_as_tuple(&buff[0], name_length, v1, v2, isWmo != 0));
+        model_list.emplace(std::piecewise_construct, std::forward_as_tuple(displayId), std::forward_as_tuple(&buff[0], name_length, v1, v2));
     }
 
     TC_LOG_INFO("server.loading", ">> Loaded {} GameObject models in {} ms", uint32(model_list.size()), GetMSTimeDiffToNow(oldMSTime));
@@ -144,7 +141,6 @@ bool GameObjectModel::initialize(std::unique_ptr<GameObjectModelOwnerBase> model
 #endif
 
     owner = std::move(modelOwner);
-    isWmo = it->second.isWmo;
     return true;
 }
 
@@ -160,6 +156,11 @@ GameObjectModel* GameObjectModel::Create(std::unique_ptr<GameObjectModelOwnerBas
     return mdl;
 }
 
+bool GameObjectModel::isMapObject() const
+{
+    return !iModel->IsM2();
+}
+
 bool GameObjectModel::intersectRay(G3D::Ray const& ray, float& maxDist, bool stopAtFirstHit, PhaseShift const& phaseShift, VMAP::ModelIgnoreFlags ignoreFlags) const
 {
     if (!isCollisionEnabled() || !owner->IsSpawned())
diff --git a/src/common/Collision/Models/GameObjectModel.h b/src/common/Collision/Models/GameObjectModel.h
index a84fac60aa2..fd11e5c1909 100644
--- a/src/common/Collision/Models/GameObjectModel.h
+++ b/src/common/Collision/Models/GameObjectModel.h
@@ -60,7 +60,7 @@ public:
 
 class TC_COMMON_API GameObjectModel /*, public Intersectable*/
 {
-    GameObjectModel() : _collisionEnabled(false), iInvScale(0), iScale(0), iModel(nullptr), isWmo(false) { }
+    GameObjectModel() : _collisionEnabled(false), iInvScale(0), iScale(0), iModel(nullptr) { }
 public:
     const G3D::AABox& getBounds() const { return iBound; }
 
@@ -71,7 +71,7 @@ public:
     /* Enables/disables collision */
     void enableCollision(bool enable) { _collisionEnabled = enable; }
     bool isCollisionEnabled() const { return _collisionEnabled; }
-    bool isMapObject() const { return isWmo; }
+    bool isMapObject() const;
     uint8 GetNameSetId() const { return owner->GetNameSetId(); }
 
     bool intersectRay(G3D::Ray const& ray, float& maxDist, bool stopAtFirstHit, PhaseShift const& phaseShift, VMAP::ModelIgnoreFlags ignoreFlags) const;
@@ -94,7 +94,6 @@ private:
     float iScale;
     VMAP::WorldModel* iModel;
     std::unique_ptr<GameObjectModelOwnerBase> owner;
-    bool isWmo;
 };
 
 TC_COMMON_API bool LoadGameObjectModelList(std::string const& dataPath);
diff --git a/src/common/Collision/Models/ModelInstance.cpp b/src/common/Collision/Models/ModelInstance.cpp
index 783db84caca..989a5710afe 100644
--- a/src/common/Collision/Models/ModelInstance.cpp
+++ b/src/common/Collision/Models/ModelInstance.cpp
@@ -74,7 +74,7 @@ namespace VMAP
         }
 
         // M2 files don't contain area info, only WMO files
-        if (flags & MOD_M2)
+        if (iModel->IsM2())
             return;
         if (!iBound.contains(p))
             return;
@@ -108,7 +108,7 @@ namespace VMAP
         }
 
         // M2 files don't contain area info, only WMO files
-        if (flags & MOD_M2)
+        if (iModel->IsM2())
             return false;
         if (!iBound.contains(p))
             return false;
diff --git a/src/common/Collision/Models/ModelInstance.h b/src/common/Collision/Models/ModelInstance.h
index 6ea4264a7c6..d44a867ae3c 100644
--- a/src/common/Collision/Models/ModelInstance.h
+++ b/src/common/Collision/Models/ModelInstance.h
@@ -32,11 +32,10 @@ namespace VMAP
     struct LocationInfo;
     enum class ModelIgnoreFlags : uint32;
 
-    enum ModelFlags
+    enum ModelInstanceFlags
     {
-        MOD_M2 = 1,
-        MOD_HAS_BOUND = 1 << 1,
-        MOD_PARENT_SPAWN = 1 << 2
+        MOD_HAS_BOUND       = 1 << 0,
+        MOD_PARENT_SPAWN    = 1 << 1
     };
 
     struct ModelMinimalData
diff --git a/src/common/Collision/Models/WorldModel.cpp b/src/common/Collision/Models/WorldModel.cpp
index 70e21e544db..1e9b2e44ddb 100644
--- a/src/common/Collision/Models/WorldModel.cpp
+++ b/src/common/Collision/Models/WorldModel.cpp
@@ -471,7 +471,7 @@ namespace VMAP
         if ((ignoreFlags & ModelIgnoreFlags::M2) != ModelIgnoreFlags::Nothing)
         {
             // M2 models are not taken into account for LoS calculation if caller requested their ignoring.
-            if (Flags & MOD_M2)
+            if (Flags.HasFlag(ModelFlags::None))
                 return false;
         }
 
@@ -569,6 +569,11 @@ namespace VMAP
         if (result && fwrite("WMOD", 1, 4, wf) != 4) result = false;
         chunkSize = sizeof(uint32) + sizeof(uint32);
         if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) result = false;
+        if (result)
+        {
+            uint32 flags = Flags.AsUnderlyingType();
+            if (fwrite(&flags, sizeof(uint32), 1, wf) != 1) result = false;
+        }
         if (result && fwrite(&RootWMOID, sizeof(uint32), 1, wf) != 1) result = false;
 
         // write group models
@@ -605,6 +610,14 @@ namespace VMAP
 
         if (result && !readChunk(rf, chunk, "WMOD", 4)) result = false;
         if (result && fread(&chunkSize, sizeof(uint32), 1, rf) != 1) result = false;
+        if (result)
+        {
+            ModelFlags flags;
+            if (fread(&flags, sizeof(flags), 1, rf) == 1)
+                Flags = flags;
+            else
+                result = false;
+        }
         if (result && fread(&RootWMOID, sizeof(uint32), 1, rf) != 1) result = false;
 
         // read group models
diff --git a/src/common/Collision/Models/WorldModel.h b/src/common/Collision/Models/WorldModel.h
index 57ac1941e48..35ffa57b4d2 100644
--- a/src/common/Collision/Models/WorldModel.h
+++ b/src/common/Collision/Models/WorldModel.h
@@ -24,6 +24,7 @@
 #include "BoundingIntervalHierarchy.h"
 
 #include "Define.h"
+#include "EnumFlag.h"
 
 namespace VMAP
 {
@@ -33,6 +34,14 @@ namespace VMAP
     struct GroupLocationInfo;
     enum class ModelIgnoreFlags : uint32;
 
+    enum class ModelFlags : uint32
+    {
+        None    = 0x0,
+        IsM2    = 0x1
+    };
+
+    DEFINE_ENUM_FLAG(ModelFlags);
+
     struct MeshTriangle
     {
         uint32 idx0;
@@ -106,21 +115,23 @@ namespace VMAP
     class TC_COMMON_API WorldModel
     {
         public:
-            WorldModel(): Flags(0), RootWMOID(0) { }
+            WorldModel(): Flags(ModelFlags::None), RootWMOID(0) { }
 
             //! pass group models to WorldModel and create BIH. Passed vector is swapped with old geometry!
             void setGroupModels(std::vector<GroupModel> &models);
+            void setFlags(ModelFlags flags) { Flags = flags; }
             void setRootWmoID(uint32 id) { RootWMOID = id; }
             bool IntersectRay(const G3D::Ray &ray, float &distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
             bool IntersectPoint(const G3D::Vector3 &p, const G3D::Vector3 &down, float &dist, AreaInfo &info) const;
             bool GetLocationInfo(const G3D::Vector3 &p, const G3D::Vector3 &down, float &dist, GroupLocationInfo& info) const;
             bool writeFile(const std::string &filename);
             bool readFile(const std::string &filename);
+            bool IsM2() const { return Flags.HasFlag(ModelFlags::IsM2); }
             std::vector<GroupModel> const& getGroupModels() const { return groupModels; }
             std::string const& GetName() const { return name; }
             void SetName(std::string newName) { name = std::move(newName); }
-            uint32 Flags;
         protected:
+            EnumFlag<ModelFlags> Flags;
             uint32 RootWMOID;
             std::vector<GroupModel> groupModels;
             BIH groupTree;
diff --git a/src/tools/mmaps_generator/TerrainBuilder.cpp b/src/tools/mmaps_generator/TerrainBuilder.cpp
index 20acd1737c8..6d836abd459 100644
--- a/src/tools/mmaps_generator/TerrainBuilder.cpp
+++ b/src/tools/mmaps_generator/TerrainBuilder.cpp
@@ -622,7 +622,7 @@ namespace MMAP
                 std::vector<GroupModel> const& groupModels = worldModel->getGroupModels();
 
                 // all M2s need to have triangle indices reversed
-                bool isM2 = (instance.flags & MOD_M2) != 0;
+                bool isM2 = worldModel->IsM2();
 
                 // transform data
                 float scale = instance.iScale;
diff --git a/src/tools/vmap4_assembler/TileAssembler.cpp b/src/tools/vmap4_assembler/TileAssembler.cpp
index 62f2be7ca66..888d483466f 100644
--- a/src/tools/vmap4_assembler/TileAssembler.cpp
+++ b/src/tools/vmap4_assembler/TileAssembler.cpp
@@ -25,11 +25,6 @@
 #include <set>
 #include <sstream>
 
-using G3D::Vector3;
-using G3D::AABox;
-using G3D::inf;
-using std::pair;
-
 template<> struct BoundsTrait<VMAP::ModelSpawn*>
 {
     static void getBounds(VMAP::ModelSpawn const* const& obj, G3D::AABox& out) { out = obj->getBounds(); }
@@ -37,9 +32,9 @@ template<> struct BoundsTrait<VMAP::ModelSpawn*>
 
 namespace VMAP
 {
-    Vector3 ModelPosition::transform(Vector3 const& pIn) const
+    G3D::Vector3 ModelPosition::transform(G3D::Vector3 const& pIn) const
     {
-        Vector3 out = pIn * iScale;
+        G3D::Vector3 out = pIn * iScale;
         out = iRotation * out;
         return out;
     }
@@ -77,21 +72,21 @@ namespace VMAP
             for (auto entry = data.UniqueEntries.begin(); entry != data.UniqueEntries.end(); ++entry)
             {
                 // M2 models don't have a bound set in WDT/ADT placement data, they're not used for LoS but are needed for pathfinding
-                if (entry->second.flags & MOD_M2)
+                if (!(entry->second.flags & MOD_HAS_BOUND))
                     if (!calculateTransformedBound(entry->second))
                         continue;
 
                 mapSpawns.push_back(&entry->second);
                 spawnedModelFiles.insert(entry->second.name);
 
-                std::map<uint32, std::set<TileSpawn>>& tileEntries = (entry->second.flags & MOD_PARENT_SPAWN) ? data.ParentTileEntries : data.TileEntries;
+                std::map<uint32, std::set<uint32>>& tileEntries = (entry->second.flags & MOD_PARENT_SPAWN) ? data.ParentTileEntries : data.TileEntries;
 
                 G3D::AABox const& bounds = entry->second.iBound;
                 G3D::Vector2int16 low(int16(bounds.low().x * invTileSize), int16(bounds.low().y * invTileSize));
                 G3D::Vector2int16 high(int16(bounds.high().x * invTileSize), int16(bounds.high().y * invTileSize));
                 for (int x = low.x; x <= high.x; ++x)
                     for (int y = low.y; y <= high.y; ++y)
-                        tileEntries[StaticMapTree::packTileID(x, y)].emplace(entry->second.ID, entry->second.flags);
+                        tileEntries[StaticMapTree::packTileID(x, y)].insert(entry->second.ID);
             }
 
             printf("Creating map tree for map %u...\n", data.MapId);
@@ -147,7 +142,7 @@ namespace VMAP
                 std::string tileFileName = Trinity::StringFormat("{}/{:04}_{:02}_{:02}.vmtile", iDestDir, data.MapId, y, x);
                 if (FILE* tileFile = fopen(tileFileName.c_str(), "wb"))
                 {
-                    std::set<TileSpawn> const& parentTileEntries = data.ParentTileEntries[tileItr->first];
+                    std::set<uint32> const& parentTileEntries = data.ParentTileEntries[tileItr->first];
 
                     uint32 nSpawns = tileItr->second.size() + parentTileEntries.size();
 
@@ -157,10 +152,10 @@ namespace VMAP
                     if (success && fwrite(&nSpawns, sizeof(uint32), 1, tileFile) != 1) success = false;
                     // write tile spawns
                     for (auto spawnItr = tileItr->second.begin(); spawnItr != tileItr->second.end() && success; ++spawnItr)
-                        success = ModelSpawn::writeToFile(tileFile, data.UniqueEntries[spawnItr->Id]);
+                        success = ModelSpawn::writeToFile(tileFile, data.UniqueEntries[*spawnItr]);
 
                     for (auto spawnItr = parentTileEntries.begin(); spawnItr != parentTileEntries.end() && success; ++spawnItr)
-                        success = ModelSpawn::writeToFile(tileFile, data.UniqueEntries[spawnItr->Id]);
+                        success = ModelSpawn::writeToFile(tileFile, data.UniqueEntries[*spawnItr]);
 
                     fclose(tileFile);
                 }
@@ -247,7 +242,7 @@ namespace VMAP
         if (groups != 1)
             printf("Warning: '%s' does not seem to be a M2 model!\n", modelFilename.c_str());
 
-        AABox rotated_bounds;
+        G3D::AABox rotated_bounds;
         for (int i = 0; i < 8; ++i)
             rotated_bounds.merge(modelPosition.transform(raw_model.groupsArray[0].bounds.corner(i)));
 
@@ -281,6 +276,7 @@ namespace VMAP
 
         // write WorldModel
         WorldModel model;
+        model.setFlags(raw_model.Flags);
         model.setRootWmoID(raw_model.RootWMOID);
         if (!raw_model.groupsArray.empty())
         {
@@ -326,7 +322,6 @@ namespace VMAP
         fwrite(VMAP::VMAP_MAGIC, 1, 8, model_list_copy);
 
         uint32 name_length, displayId;
-        uint8 isWmo;
         char buff[500];
         while (true)
         {
@@ -334,8 +329,7 @@ namespace VMAP
                 if (feof(model_list))   // EOF flag is only set after failed reading attempt
                     break;
 
-            if (fread(&isWmo, sizeof(uint8), 1, model_list) != 1
-                || fread(&name_length, sizeof(uint32), 1, model_list) != 1
+            if (fread(&name_length, sizeof(uint32), 1, model_list) != 1
                 || name_length >= sizeof(buff)
                 || fread(&buff, sizeof(char), name_length, model_list) != name_length)
             {
@@ -350,7 +344,7 @@ namespace VMAP
                 continue;
 
             spawnedModelFiles.insert(model_name);
-            AABox bounds;
+            G3D::AABox bounds;
             for (GroupModel_Raw const& groupModel : raw_model.groupsArray)
                 for (G3D::Vector3 const& vertice : groupModel.vertexArray)
                     bounds.merge(vertice);
@@ -368,11 +362,10 @@ namespace VMAP
             }
 
             fwrite(&displayId, sizeof(uint32), 1, model_list_copy);
-            fwrite(&isWmo, sizeof(uint8), 1, model_list_copy);
             fwrite(&name_length, sizeof(uint32), 1, model_list_copy);
             fwrite(&buff, sizeof(char), name_length, model_list_copy);
-            fwrite(&bounds.low(), sizeof(Vector3), 1, model_list_copy);
-            fwrite(&bounds.high(), sizeof(Vector3), 1, model_list_copy);
+            fwrite(&bounds.low(), sizeof(G3D::Vector3), 1, model_list_copy);
+            fwrite(&bounds.high(), sizeof(G3D::Vector3), 1, model_list_copy);
         }
 
         fclose(model_list);
@@ -396,10 +389,10 @@ namespace VMAP
         READ_OR_RETURN(&mogpflags, sizeof(uint32));
         READ_OR_RETURN(&GroupWMOID, sizeof(uint32));
 
-        Vector3 vec1, vec2;
-        READ_OR_RETURN(&vec1, sizeof(Vector3));
+        G3D::Vector3 vec1, vec2;
+        READ_OR_RETURN(&vec1, sizeof(G3D::Vector3));
 
-        READ_OR_RETURN(&vec2, sizeof(Vector3));
+        READ_OR_RETURN(&vec2, sizeof(G3D::Vector3));
         bounds.set(vec1, vec2);
 
         READ_OR_RETURN(&liquidflags, sizeof(uint32));
@@ -429,7 +422,7 @@ namespace VMAP
             READ_OR_RETURN_WITH_DELETE(indexarray, nindexes*sizeof(uint32));
             triangles.reserve(nindexes / 3);
             for (uint32 i=0; i<nindexes; i+=3)
-                triangles.push_back(MeshTriangle(indexarray[i], indexarray[i+1], indexarray[i+2]));
+                triangles.push_back({ .idx0 = indexarray[i], .idx1 = indexarray[i + 1], .idx2 = indexarray[i + 2] });
 
             delete[] indexarray;
         }
@@ -446,7 +439,7 @@ namespace VMAP
             float *vectorarray = new float[nvectors*3];
             READ_OR_RETURN_WITH_DELETE(vectorarray, nvectors*sizeof(float)*3);
             for (uint32 i=0; i<nvectors; ++i)
-                vertexArray.push_back( Vector3(vectorarray + 3*i) );
+                vertexArray.push_back(G3D::Vector3(vectorarray + 3*i) );
 
             delete[] vectorarray;
         }
@@ -463,7 +456,7 @@ namespace VMAP
             {
                 WMOLiquidHeader hlq;
                 READ_OR_RETURN(&hlq, sizeof(WMOLiquidHeader));
-                liquid = new WmoLiquid(hlq.xtiles, hlq.ytiles, Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), liquidType);
+                liquid = new WmoLiquid(hlq.xtiles, hlq.ytiles, G3D::Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), liquidType);
                 uint32 size = hlq.xverts * hlq.yverts;
                 READ_OR_RETURN(liquid->GetHeightStorage(), size * sizeof(float));
                 size = hlq.xtiles * hlq.ytiles;
@@ -471,7 +464,7 @@ namespace VMAP
             }
             else
             {
-                liquid = new WmoLiquid(0, 0, Vector3::zero(), liquidType);
+                liquid = new WmoLiquid(0, 0, G3D::Vector3::zero(), liquidType);
                 liquid->GetHeightStorage()[0] = bounds.high().z;
             }
         }
@@ -506,6 +499,7 @@ namespace VMAP
         uint32 groups;
         READ_OR_RETURN(&groups, sizeof(uint32));
         READ_OR_RETURN(&RootWMOID, sizeof(uint32));
+        READ_OR_RETURN(&Flags, sizeof(Flags));
 
         groupsArray.resize(groups);
         bool succeed = true;
diff --git a/src/tools/vmap4_assembler/TileAssembler.h b/src/tools/vmap4_assembler/TileAssembler.h
index 73b58941de4..b2ec8fd73b5 100644
--- a/src/tools/vmap4_assembler/TileAssembler.h
+++ b/src/tools/vmap4_assembler/TileAssembler.h
@@ -20,7 +20,6 @@
 
 #include <G3D/Vector3.h>
 #include <G3D/Matrix3.h>
-#include <compare>
 #include <deque>
 #include <map>
 #include <set>
@@ -53,25 +52,12 @@ namespace VMAP
             void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; }
     };
 
-    struct TileSpawn
-    {
-        TileSpawn() : Id(0), Flags(0) { }
-        TileSpawn(uint32 id, uint32 flags) : Id(id), Flags(flags) { }
-
-        uint32 Id;
-        uint32 Flags;
-
-        std::strong_ordering operator<=>(TileSpawn const& right) const { return Id <=> right.Id; }
-    };
-
     struct MapSpawns
     {
-        MapSpawns() { }
-
-        uint32 MapId;
+        uint32 MapId = 0;
         std::map<uint32, ModelSpawn> UniqueEntries;
-        std::map<uint32 /*packedTileId*/, std::set<TileSpawn>> TileEntries;
-        std::map<uint32 /*packedTileId*/, std::set<TileSpawn>> ParentTileEntries;
+        std::map<uint32 /*packedTileId*/, std::set<uint32 /*Id*/>> TileEntries;
+        std::map<uint32 /*packedTileId*/, std::set<uint32 /*Id*/>> ParentTileEntries;
     };
 
     typedef std::deque<MapSpawns> MapData;
@@ -97,6 +83,7 @@ namespace VMAP
 
     struct WorldModel_Raw
     {
+        ModelFlags Flags;
         uint32 RootWMOID;
         std::vector<GroupModel_Raw> groupsArray;
 
diff --git a/src/tools/vmap4_extractor/gameobject_extract.cpp b/src/tools/vmap4_extractor/gameobject_extract.cpp
index 78d95ff2669..7cd77764609 100644
--- a/src/tools/vmap4_extractor/gameobject_extract.cpp
+++ b/src/tools/vmap4_extractor/gameobject_extract.cpp
@@ -119,12 +119,8 @@ void ExtractGameobjectModels()
         if (!GetHeaderMagic(fileName, &header))
             continue;
 
-        uint8 isWmo = 0;
         if (!memcmp(&header, "REVM", 4))
-        {
-            isWmo = 1;
             result = ExtractSingleWmo(fileName);
-        }
         else if (!memcmp(&header, "MD20", 4) || !memcmp(&header, "MD21", 4))
             result = ExtractSingleModel(fileName);
         else
@@ -135,7 +131,6 @@ void ExtractGameobjectModels()
             uint32 displayId = record.GetId();
             uint32 path_length = fileName.length();
             fwrite(&displayId, sizeof(uint32), 1, model_list);
-            fwrite(&isWmo, sizeof(uint8), 1, model_list);
             fwrite(&path_length, sizeof(uint32), 1, model_list);
             fwrite(fileName.c_str(), sizeof(char), path_length, model_list);
         }
diff --git a/src/tools/vmap4_extractor/model.cpp b/src/tools/vmap4_extractor/model.cpp
index f49df2ea119..f1272cb28a6 100644
--- a/src/tools/vmap4_extractor/model.cpp
+++ b/src/tools/vmap4_extractor/model.cpp
@@ -99,7 +99,10 @@ bool Model::ConvertToVMAPModel(const char * outfilename)
     fwrite(&nVertices, sizeof(int), 1, output);
     uint32 nofgroups = 1;
     fwrite(&nofgroups, sizeof(uint32), 1, output);
-    fwrite(N, 4 * 3, 1, output);// rootwmoid, flags, groupid
+    fwrite(N, 4, 1, output);// RootWMOID
+    ModelFlags tcFlags = ModelFlags::IsM2;
+    fwrite(&tcFlags, sizeof(ModelFlags), 1, output);
+    fwrite(N, 4 * 2, 1, output);// mogpFlags, groupWMOID
     fwrite(&bounds, sizeof(AaBox3D), 1, output);//bbox, only needed for WMO currently
     fwrite(N, 4, 1, output);// liquidflags
     fwrite("GRP ", 4, 1, output);
@@ -177,7 +180,7 @@ void Doodad::Extract(ADT::MDDF const& doodadDef, char const* ModelInstName, uint
 
     uint8 nameSet = 0;// not used for models
     uint32 uniqueId = GenerateUniqueObjectId(doodadDef.UniqueId, 0, false);
-    uint8 tcflags = MOD_M2;
+    uint8 tcflags = 0;
     if (mapID != originalMapId)
         tcflags |= MOD_PARENT_SPAWN;
 
@@ -285,7 +288,7 @@ void Doodad::ExtractSet(WMODoodadData const& doodadData, ADT::MODF const& wmo, b
 
             uint8 nameSet = 0;     // not used for models
             uint32 uniqueId = GenerateUniqueObjectId(wmo.UniqueId, doodadId, false);
-            uint8 tcflags = MOD_M2;
+            uint8 tcflags = 0;
             if (mapID != originalMapId)
                 tcflags |= MOD_PARENT_SPAWN;
 
diff --git a/src/tools/vmap4_extractor/vmapexport.h b/src/tools/vmap4_extractor/vmapexport.h
index 611e9711604..49129ded1ac 100644
--- a/src/tools/vmap4_extractor/vmapexport.h
+++ b/src/tools/vmap4_extractor/vmapexport.h
@@ -22,11 +22,18 @@
 #include <string>
 #include <unordered_map>
 
-enum ModelFlags
+// flags of each spawn
+enum ModelInstanceFlags
 {
-    MOD_M2 = 1,
-    MOD_HAS_BOUND = 1 << 1,
-    MOD_PARENT_SPAWN = 1 << 2
+    MOD_HAS_BOUND       = 1 << 0,
+    MOD_PARENT_SPAWN    = 1 << 1
+};
+
+// flags of each model
+enum class ModelFlags : uint32
+{
+    None    = 0x0,
+    IsM2    = 0x1
 };
 
 struct WMODoodadData;
diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp
index de53598c3d5..4301e758cb5 100644
--- a/src/tools/vmap4_extractor/wmo.cpp
+++ b/src/tools/vmap4_extractor/wmo.cpp
@@ -200,6 +200,8 @@ bool WMORoot::ConvertToVMAPRootWmo(FILE* pOutfile)
     fwrite(&nVectors,sizeof(nVectors), 1, pOutfile); // will be filled later
     fwrite(&nGroups, 4, 1, pOutfile);
     fwrite(&RootWMOID, 4, 1, pOutfile);
+    ModelFlags tcFlags = ModelFlags::None;
+    fwrite(&tcFlags, sizeof(ModelFlags), 1, pOutfile);
     return true;
 }