* Move VMap3 code to a separate static 'collision' library.

--HG--
branch : trunk

4 files changed, 1130 insertions, 0 deletions

diff --git a/src/server/collision/Maps/MapTree.cpp b/src/server/collision/Maps/MapTree.cpp
new file mode 100644
index 00000000000..8c77ee109f3
--- /dev/null
+++ b/src/server/collision/Maps/MapTree.cpp
@@ -0,0 +1,450 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "MapTree.h"
+#include "ModelInstance.h"
+#include "VMapManager2.h"
+#include "VMapDefinitions.h"
+
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+using G3D::Vector3;
+
+namespace VMAP
+{
+
+    class MapRayCallback
+    {
+        public:
+            MapRayCallback(ModelInstance *val): prims(val) {}
+            ModelInstance *prims;
+            bool operator()(const G3D::Ray& ray, uint32 entry, float& distance, bool pStopAtFirstHit=true)
+            {
+                return prims[entry].intersectRay(ray, distance, pStopAtFirstHit);
+                //std::cout << "trying to intersect '" << entity->name << "'\n";
+            }
+    };
+
+    class AreaInfoCallback
+    {
+        public:
+            AreaInfoCallback(ModelInstance *val): prims(val) {}
+            void operator()(const Vector3& point, uint32 entry)
+            {
+#ifdef VMAP_DEBUG
+                std::cout << "trying to intersect '" << prims[entry].name << "'\n";
+#endif
+                prims[entry].intersectPoint(point, aInfo);
+            }
+
+            ModelInstance *prims;
+            AreaInfo aInfo;
+    };
+
+    class LocationInfoCallback
+    {
+        public:
+            LocationInfoCallback(ModelInstance *val, LocationInfo &info): prims(val), locInfo(info), result(false) {}
+            void operator()(const Vector3& point, uint32 entry)
+            {
+#ifdef VMAP_DEBUG
+                std::cout << "trying to intersect '" << prims[entry].name << "'\n";
+#endif
+                if (prims[entry].GetLocationInfo(point, locInfo))
+                    result = true;
+            }
+
+            ModelInstance *prims;
+            LocationInfo &locInfo;
+            bool result;
+    };
+
+
+    //=========================================================
+
+    std::string StaticMapTree::getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY)
+    {
+        std::stringstream tilefilename;
+        tilefilename.fill('0');
+        tilefilename << std::setw(3) << mapID << "_";
+        //tilefilename << std::setw(2) << tileX << "_" << std::setw(2) << tileY << ".vmtile";
+        tilefilename << std::setw(2) << tileY << "_" << std::setw(2) << tileX << ".vmtile";
+        return tilefilename.str();
+    }
+
+    bool StaticMapTree::getAreaInfo(Vector3 &pos, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const
+    {
+        AreaInfoCallback intersectionCallBack(iTreeValues);
+        iTree.intersectPoint(pos, intersectionCallBack);
+        if (intersectionCallBack.aInfo.result)
+        {
+            flags = intersectionCallBack.aInfo.flags;
+            adtId = intersectionCallBack.aInfo.adtId;
+            rootId = intersectionCallBack.aInfo.rootId;
+            groupId = intersectionCallBack.aInfo.groupId;
+            pos.z = intersectionCallBack.aInfo.ground_Z;
+            return true;
+        }
+        return false;
+    }
+
+    bool StaticMapTree::GetLocationInfo(const Vector3 &pos, LocationInfo &info) const
+    {
+        LocationInfoCallback intersectionCallBack(iTreeValues, info);
+        iTree.intersectPoint(pos, intersectionCallBack);
+        return intersectionCallBack.result;
+    }
+
+    StaticMapTree::StaticMapTree(uint32 mapID, const std::string &basePath):
+        iMapID(mapID), /* iTree(0), */ iTreeValues(0), iBasePath(basePath)
+    {
+        if (iBasePath.length() > 0 && (iBasePath[iBasePath.length()-1] != '/' || iBasePath[iBasePath.length()-1] != '\\'))
+        {
+            iBasePath.append("/");
+        }
+    }
+
+    //=========================================================
+    //! Make sure to call unloadMap() to unregister acquired model references before destroying
+    StaticMapTree::~StaticMapTree()
+    {
+        delete[] iTreeValues;
+    }
+
+    //=========================================================
+    /**
+    return dist to hit or inf() if no hit
+    */
+
+    float StaticMapTree::getIntersectionTime(const G3D::Ray& pRay, float pMaxDist, bool pStopAtFirstHit) const
+    {
+        float distance = pMaxDist;
+        MapRayCallback intersectionCallBack(iTreeValues);
+        iTree.intersectRay(pRay, intersectionCallBack, distance, pStopAtFirstHit);
+        return distance;
+    }
+    //=========================================================
+
+    bool StaticMapTree::isInLineOfSight(const Vector3& pos1, const Vector3& pos2) const
+    {
+        bool result = true;
+        float maxDist = (pos2 - pos1).magnitude();
+        // prevent NaN values which can cause BIH intersection to enter infinite loop
+        if (maxDist < 1e-10f)
+            return true;
+        // direction with length of 1
+        G3D::Ray ray = G3D::Ray::fromOriginAndDirection(pos1, (pos2 - pos1)/maxDist);
+        float resultDist = getIntersectionTime(ray, maxDist, true);
+        if (resultDist < maxDist)
+        {
+            result = false;
+        }
+        return result;
+    }
+    //=========================================================
+    /**
+    When moving from pos1 to pos2 check if we hit an object. Return true and the position if we hit one
+    Return the hit pos or the original dest pos
+    */
+
+    bool StaticMapTree::getObjectHitPos(const Vector3& pPos1, const Vector3& pPos2, Vector3& pResultHitPos, float pModifyDist) const
+    {
+        bool result=false;
+        float maxDist = (pPos2 - pPos1).magnitude();
+        // prevent NaN values which can cause BIH intersection to enter infinite loop
+        if (maxDist < 1e-10f)
+        {
+            pResultHitPos = pPos2;
+            return false;
+        }
+        Vector3 dir = (pPos2 - pPos1)/maxDist;              // direction with length of 1
+        G3D::Ray ray(pPos1, dir);
+        float dist = getIntersectionTime(ray, maxDist, false);
+        if (dist < maxDist)
+        {
+            pResultHitPos = pPos1 + dir * dist;
+            if (pModifyDist < 0)
+            {
+                if ((pResultHitPos - pPos1).magnitude() > -pModifyDist)
+                {
+                    pResultHitPos = pResultHitPos + dir*pModifyDist;
+                }
+                else
+                {
+                    pResultHitPos = pPos1;
+                }
+            }
+            else
+            {
+                pResultHitPos = pResultHitPos + dir*pModifyDist;
+            }
+            result = true;
+        }
+        else
+        {
+            pResultHitPos = pPos2;
+            result = false;
+        }
+        return result;
+    }
+
+    //=========================================================
+
+    float StaticMapTree::getHeight(const Vector3& pPos) const
+    {
+        float height = G3D::inf();
+        Vector3 dir = Vector3(0,0,-1);
+        G3D::Ray ray(pPos, dir);   // direction with length of 1
+        float maxDist = VMapDefinitions::getMaxCanFallDistance();
+        float dist = getIntersectionTime(ray, maxDist, false);
+        if (dist < maxDist)
+        {
+            height = pPos.z - dist;
+        }
+        return(height);
+    }
+
+    //=========================================================
+
+    bool StaticMapTree::CanLoadMap(const std::string &vmapPath, uint32 mapID, uint32 tileX, uint32 tileY)
+    {
+        std::string basePath = vmapPath;
+        if (basePath.length() > 0 && (basePath[basePath.length()-1] != '/' || basePath[basePath.length()-1] != '\\'))
+            basePath.append("/");
+        std::string fullname = basePath + VMapManager2::getMapFileName(mapID);
+        bool success = true;
+        FILE *rf = fopen(fullname.c_str(), "rb");
+        if (!rf)
+            return false;
+        // TODO: check magic number when implemented...
+        char tiled;
+        char chunk[8];
+        if (!readChunk(rf, chunk, VMAP_MAGIC, 8) || fread(&tiled, sizeof(char), 1, rf) != 1)
+        {
+            fclose(rf);
+            return false;
+        }
+        if (tiled)
+        {
+            std::string tilefile = basePath + getTileFileName(mapID, tileX, tileY);
+            FILE* tf = fopen(tilefile.c_str(), "rb");
+            if (!tf)
+                success = false;
+            else
+                fclose(tf);
+        }
+        fclose(rf);
+        return success;
+    }
+
+    //=========================================================
+
+    bool StaticMapTree::InitMap(const std::string &fname, VMapManager2 *vm)
+    {
+        std::cout << "Initializing StaticMapTree '" << fname << "'\n";
+        bool success = true;
+        std::string fullname = iBasePath + fname;
+        FILE *rf = fopen(fullname.c_str(), "rb");
+        if (!rf)
+            return false;
+        else
+        {
+            char chunk[8];
+            //general info
+            if (!readChunk(rf, chunk, VMAP_MAGIC, 8)) success = false;
+            char tiled;
+            if (success && fread(&tiled, sizeof(char), 1, rf) != 1) success = false;
+            iIsTiled = bool(tiled);
+            // Nodes
+            if (success && !readChunk(rf, chunk, "NODE", 4)) success = false;
+            if (success) success = iTree.readFromFile(rf);
+            if (success)
+            {
+                iNTreeValues = iTree.primCount();
+                iTreeValues = new ModelInstance[iNTreeValues];
+            }
+
+            if (success && !readChunk(rf, chunk, "GOBJ", 4)) success = false;
+            // global model spawns
+            // only non-tiled maps have them, and if so exactly one (so far at least...)
+            ModelSpawn spawn;
+#ifdef VMAP_DEBUG
+            std::cout << "Map isTiled:" << bool(iIsTiled) << std::endl;
+#endif
+            if (!iIsTiled && ModelSpawn::readFromFile(rf, spawn))
+            {
+                WorldModel *model = vm->acquireModelInstance(iBasePath, spawn.name);
+                std::cout << "StaticMapTree::InitMap(): loading " << spawn.name << std::endl;
+                if (model)
+                {
+                    // assume that global model always is the first and only tree value (could be improved...)
+                    iTreeValues[0] = ModelInstance(spawn, model);
+                    iLoadedSpawns[0] = 1;
+                }
+                else
+                {
+                    success = false;
+                    std::cout << "error: could not acquire WorldModel pointer!\n";
+                }
+            }
+
+            fclose(rf);
+        }
+        return success;
+    }
+
+    //=========================================================
+
+    void StaticMapTree::UnloadMap(VMapManager2 *vm)
+    {
+        for (loadedSpawnMap::iterator i = iLoadedSpawns.begin(); i != iLoadedSpawns.end(); ++i)
+        {
+            iTreeValues[i->first].setUnloaded();
+            for (uint32 refCount = 0; refCount < i->second; ++refCount)
+                vm->releaseModelInstance(iTreeValues[i->first].name);
+        }
+        iLoadedSpawns.clear();
+        iLoadedTiles.clear();
+    }
+
+    //=========================================================
+
+    bool StaticMapTree::LoadMapTile(uint32 tileX, uint32 tileY, VMapManager2 *vm)
+    {
+        if (!iIsTiled)
+        {
+            // currently, core creates grids for all maps, whether it has terrain tiles or not
+            // so we need "fake" tile loads to know when we can unload map geometry
+            iLoadedTiles[packTileID(tileX, tileY)] = false;
+            return true;
+        }
+        if (!iTreeValues)
+        {
+            std::cout << "Tree has not been initialized!\n";
+            return false;
+        }
+        bool result = true;
+
+        std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
+        FILE* tf = fopen(tilefile.c_str(), "rb");
+        if (tf)
+        {
+            uint32 numSpawns;
+            if (fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
+                result = false;
+            for (uint32 i=0; i<numSpawns && result; ++i)
+            {
+                // read model spawns
+                ModelSpawn spawn;
+                result = ModelSpawn::readFromFile(tf, spawn);
+                if (result)
+                {
+                    // acquire model instance
+                    WorldModel *model = vm->acquireModelInstance(iBasePath, spawn.name);
+                    if (!model) std::cout << "error: could not acquire WorldModel pointer!\n";
+
+                    // update tree
+                    uint32 referencedVal;
+
+                    fread(&referencedVal, sizeof(uint32), 1, tf);
+                    if (!iLoadedSpawns.count(referencedVal))
+                    {
+#ifdef VMAP_DEBUG
+                        if (referencedVal > iNTreeValues)
+                        {
+                            std::cout << "invalid tree element! (" << referencedVal << "/" << iNTreeValues << ")\n";
+                            continue;
+                        }
+#endif
+                        iTreeValues[referencedVal] = ModelInstance(spawn, model);
+                        iLoadedSpawns[referencedVal] = 1;
+                    }
+                    else
+                    {
+                        ++iLoadedSpawns[referencedVal];
+#ifdef VMAP_DEBUG
+                        if (iTreeValues[referencedVal].ID != spawn.ID) std::cout << "error: trying to load wrong spawn in node!\n";
+                        else if (iTreeValues[referencedVal].name != spawn.name) std::cout << "error: name collision on GUID="<< spawn.ID << "\n";
+#endif
+                    }
+                }
+            }
+            iLoadedTiles[packTileID(tileX, tileY)] = true;
+            fclose(tf);
+        }
+        else
+            iLoadedTiles[packTileID(tileX, tileY)] = false;
+        return result;
+    }
+
+    //=========================================================
+
+    void StaticMapTree::UnloadMapTile(uint32 tileX, uint32 tileY, VMapManager2 *vm)
+    {
+        uint32 tileID = packTileID(tileX, tileY);
+        loadedTileMap::iterator tile = iLoadedTiles.find(tileID);
+        if (tile == iLoadedTiles.end())
+        {
+            std::cout << "WARNING: trying to unload non-loaded tile. Map:" << iMapID << " X:" << tileX << " Y:" << tileY << std::endl;
+            return;
+        }
+        if (tile->second) // file associated with tile
+        {
+            std::string tilefile = iBasePath + getTileFileName(iMapID, tileX, tileY);
+            FILE* tf = fopen(tilefile.c_str(), "rb");
+            if (tf)
+            {
+                bool result=true;
+                uint32 numSpawns;
+                if (fread(&numSpawns, sizeof(uint32), 1, tf) != 1)
+                    result = false;
+                for (uint32 i=0; i<numSpawns && result; ++i)
+                {
+                    // read model spawns
+                    ModelSpawn spawn;
+                    result = ModelSpawn::readFromFile(tf, spawn);
+                    if (result)
+                    {
+                        // release model instance
+                        vm->releaseModelInstance(spawn.name);
+
+                        // update tree
+                        uint32 referencedNode;
+
+                        fread(&referencedNode, sizeof(uint32), 1, tf);
+                        if (!iLoadedSpawns.count(referencedNode))
+                        {
+                            std::cout << "error! trying to unload non-referenced model '" << spawn.name << "' (ID:" << spawn.ID << ")\n";
+                        }
+                        else if (--iLoadedSpawns[referencedNode] == 0)
+                        {
+                            //std::cout << "MapTree: removing '" << spawn.name << "' from tree\n";
+                            iTreeValues[referencedNode].setUnloaded();
+                            iLoadedSpawns.erase(referencedNode);
+                        }
+                    }
+                }
+                fclose(tf);
+            }
+        }
+        iLoadedTiles.erase(tile);
+    }
+
+}
diff --git a/src/server/collision/Maps/MapTree.h b/src/server/collision/Maps/MapTree.h
new file mode 100644
index 00000000000..7955cb92d68
--- /dev/null
+++ b/src/server/collision/Maps/MapTree.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MAPTREE_H
+#define _MAPTREE_H
+
+#include "Platform/Define.h"
+#include "Utilities/UnorderedMap.h"
+#include "BIH.h"
+
+namespace VMAP
+{
+    class ModelInstance;
+    class GroupModel;
+    class VMapManager2;
+
+    struct LocationInfo
+    {
+        LocationInfo(): hitInstance(0), hitModel(0), ground_Z(-G3D::inf()) {};
+        const ModelInstance *hitInstance;
+        const GroupModel *hitModel;
+        float ground_Z;
+    };
+
+    class StaticMapTree
+    {
+        typedef UNORDERED_MAP<uint32, bool> loadedTileMap;
+        typedef UNORDERED_MAP<uint32, uint32> loadedSpawnMap;
+        private:
+            uint32 iMapID;
+            bool iIsTiled;
+            BIH iTree;
+            ModelInstance *iTreeValues; // the tree entries
+            uint32 iNTreeValues;
+
+            // 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;
+            // stores <tree_index, reference_count> to invalidate tree values, unload map, and to be able to report errors
+            loadedSpawnMap iLoadedSpawns;
+            std::string iBasePath;
+
+        private:
+            float 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);
+
+            StaticMapTree(uint32 mapID, const std::string &basePath);
+            ~StaticMapTree();
+
+            bool isInLineOfSight(const G3D::Vector3& pos1, const G3D::Vector3& pos2) const;
+            bool getObjectHitPos(const G3D::Vector3& pos1, const G3D::Vector3& pos2, G3D::Vector3& pResultHitPos, float pModifyDist) const;
+            float getHeight(const G3D::Vector3& pPos) const;
+            bool getAreaInfo(G3D::Vector3 &pos, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const;
+            bool GetLocationInfo(const Vector3 &pos, LocationInfo &info) const;
+
+            bool InitMap(const std::string &fname, VMapManager2 *vm);
+            void UnloadMap(VMapManager2 *vm);
+            bool LoadMapTile(uint32 tileX, uint32 tileY, VMapManager2 *vm);
+            void UnloadMapTile(uint32 tileX, uint32 tileY, VMapManager2 *vm);
+            bool isTiled() const { return iIsTiled; }
+            uint32 numLoadedTiles() const { return iLoadedTiles.size(); }
+    };
+
+    struct AreaInfo
+    {
+        AreaInfo(): result(false), ground_Z(-G3D::inf()) {};
+        bool result;
+        float ground_Z;
+        uint32 flags;
+        int32 adtId;
+        int32 rootId;
+        int32 groupId;
+    };
+}                                                           // VMAP
+
+#endif // _MAPTREE_H
diff --git a/src/server/collision/Maps/TileAssembler.cpp b/src/server/collision/Maps/TileAssembler.cpp
new file mode 100644
index 00000000000..d01b54a7564
--- /dev/null
+++ b/src/server/collision/Maps/TileAssembler.cpp
@@ -0,0 +1,494 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "WorldModel.h"
+#include "TileAssembler.h"
+#include "MapTree.h"
+#include "BIH.h"
+#include "VMapDefinitions.h"
+
+#include <set>
+#include <iomanip>
+#include <sstream>
+#include <iomanip>
+
+using G3D::Vector3;
+using G3D::AABox;
+using G3D::inf;
+using std::pair;
+
+template<> struct BoundsTrait<VMAP::ModelSpawn*>
+{
+    static void getBounds(const VMAP::ModelSpawn* const &obj, G3D::AABox& out) { out = obj->getBounds(); }
+};
+
+namespace VMAP
+{
+    bool readChunk(FILE *rf, char *dest, const char *compare, uint32 len)
+    {
+        if (fread(dest, sizeof(char), len, rf) != len) return false;
+        return memcmp(dest, compare, len) == 0;
+    }
+
+    Vector3 ModelPosition::transform(const Vector3& pIn) const
+    {
+        Vector3 out = pIn * iScale;
+        out = iRotation * out;
+        return(out);
+    }
+
+    //=================================================================
+
+    TileAssembler::TileAssembler(const std::string& pSrcDirName, const std::string& pDestDirName)
+    {
+        iCurrentUniqueNameId = 0;
+        iFilterMethod = NULL;
+        iSrcDir = pSrcDirName;
+        iDestDir = pDestDirName;
+        //mkdir(iDestDir);
+        //init();
+    }
+
+    TileAssembler::~TileAssembler()
+    {
+        //delete iCoordModelMapping;
+    }
+
+    bool TileAssembler::convertWorld2()
+    {
+        std::set<std::string> spawnedModelFiles;
+        bool success = readMapSpawns();
+        if (!success)
+            return false;
+
+        // export Map data
+        for (MapData::iterator map_iter = mapData.begin(); map_iter != mapData.end() && success; ++map_iter)
+        {
+            // build global map tree
+            std::vector<ModelSpawn*> mapSpawns;
+            UniqueEntryMap::iterator entry;
+            for (entry = map_iter->second->UniqueEntries.begin(); entry != map_iter->second->UniqueEntries.end(); ++entry)
+            {
+                // M2 models don't have a bound set in WDT/ADT placement data, i still think they're not used for LoS at all on retail
+                if (entry->second.flags & MOD_M2)
+                {
+                    if (!calculateTransformedBound(entry->second))
+                        break;
+                }
+                else if (entry->second.flags & MOD_WORLDSPAWN) // WMO maps and terrain maps use different origin, so we need to adapt :/
+                {
+                    // TODO: remove extractor hack and uncomment below line:
+                    //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));
+                spawnedModelFiles.insert(entry->second.name);
+            }
+
+            BIH pTree;
+            pTree.build(mapSpawns, BoundsTrait<ModelSpawn*>::getBounds);
+
+            // ===> 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));
+            if (!modelNodeIdx.empty())
+                printf("min GUID: %u, max GUID: %u\n", modelNodeIdx.begin()->first, modelNodeIdx.rbegin()->first);
+
+            // write map tree file
+            std::stringstream mapfilename;
+            mapfilename << iDestDir << "/" << std::setfill('0') << std::setw(3) << map_iter->first << ".vmtree";
+            FILE *mapfile = fopen(mapfilename.str().c_str(), "wb");
+            if (!mapfile)
+            {
+                success = false;
+                printf("Cannot open %s\n", mapfilename.str().c_str());
+                break;
+            }
+
+            //general info
+            if (success && fwrite(VMAP_MAGIC, 1, 8, mapfile) != 8) success = false;
+            uint32 globalTileID = StaticMapTree::packTileID(65, 65);
+            pair<TileMap::iterator, TileMap::iterator> globalRange = map_iter->second->TileEntries.equal_range(globalTileID);
+            char isTiled = globalRange.first == globalRange.second; // only maps without terrain (tiles) have global WMO
+            if (success && fwrite(&isTiled, sizeof(char), 1, mapfile) != 1) success = false;
+            // Nodes
+            if (success && fwrite("NODE", 4, 1, mapfile) != 1) success = false;
+            if (success) success = pTree.writeToFile(mapfile);
+            // global map spawns (WDT), if any (most instances)
+            if (success && fwrite("GOBJ", 4, 1, mapfile) != 1) success = false;
+
+            for (TileMap::iterator glob=globalRange.first; glob != globalRange.second && success; ++glob)
+            {
+                success = ModelSpawn::writeToFile(mapfile, map_iter->second->UniqueEntries[glob->second]);
+            }
+
+            fclose(mapfile);
+
+            // <====
+
+            // write map tile files, similar to ADT files, only with extra BSP tree node info
+            TileMap &tileEntries = map_iter->second->TileEntries;
+            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...
+                    continue;
+                uint32 nSpawns = tileEntries.count(tile->first);
+                std::stringstream tilefilename;
+                tilefilename.fill('0');
+                tilefilename << iDestDir << "/" << std::setw(3) << map_iter->first << "_";
+                uint32 x, y;
+                StaticMapTree::unpackTileID(tile->first, x, y);
+                tilefilename << std::setw(2) << x << "_" << std::setw(2) << y << ".vmtile";
+                FILE *tilefile = fopen(tilefilename.str().c_str(), "wb");
+                // write number of tile spawns
+                if (success && fwrite(&nSpawns, sizeof(uint32), 1, tilefile) != 1) success = false;
+                // write tile spawns
+                for (uint32 s=0; s<nSpawns; ++s)
+                {
+                    if (s)
+                        ++tile;
+                    const ModelSpawn &spawn2 = map_iter->second->UniqueEntries[tile->second];
+                    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
+        }
+
+        // export objects
+        std::cout << "\nConverting Model Files" << std::endl;
+        for (std::set<std::string>::iterator mfile = spawnedModelFiles.begin(); mfile != spawnedModelFiles.end(); ++mfile)
+        {
+            std::cout << "Converting " << *mfile << std::endl;
+            if (!convertRawFile(*mfile))
+            {
+                std::cout << "error converting " << *mfile << std::endl;
+                success = false;
+                break;
+            }
+        }
+
+        //cleanup:
+        for (MapData::iterator map_iter = mapData.begin(); map_iter != mapData.end(); ++map_iter)
+        {
+            delete map_iter->second;
+        }
+        return success;
+    }
+
+    bool TileAssembler::readMapSpawns()
+    {
+        std::string fname = iSrcDir + "/dir_bin";
+        FILE *dirf = fopen(fname.c_str(), "rb");
+        if (!dirf)
+        {
+            printf("Could not read dir_bin file!\n");
+            return false;
+        }
+        printf("Read coordinate mapping...\n");
+        uint32 mapID, tileX, tileY, check=0;
+        G3D::Vector3 v1, v2;
+        ModelSpawn spawn;
+        while (!feof(dirf))
+        {
+            check = 0;
+            // read mapID, tileX, tileY, Flags, adtID, ID, Pos, Rot, Scale, Bound_lo, Bound_hi, name
+            check += fread(&mapID, sizeof(uint32), 1, dirf);
+            if (check == 0) // EoF...
+                break;
+            check += fread(&tileX, sizeof(uint32), 1, dirf);
+            check += fread(&tileY, sizeof(uint32), 1, dirf);
+            if (!ModelSpawn::readFromFile(dirf, spawn))
+                break;
+
+            MapSpawns *current;
+            MapData::iterator map_iter = mapData.find(mapID);
+            if (map_iter == mapData.end())
+            {
+                printf("spawning Map %d\n", mapID);
+                mapData[mapID] = current = new MapSpawns();
+            }
+            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));
+        }
+        bool success = (ferror(dirf) == 0);
+        fclose(dirf);
+        return success;
+    }
+
+    bool TileAssembler::calculateTransformedBound(ModelSpawn &spawn)
+    {
+        std::string modelFilename = iSrcDir + "/" + spawn.name;
+        ModelPosition modelPosition;
+        modelPosition.iDir = spawn.iRot;
+        modelPosition.iScale = spawn.iScale;
+        modelPosition.init();
+
+        FILE *rf = fopen(modelFilename.c_str(), "rb");
+        if (!rf)
+        {
+            printf("ERROR: Can't open model file: %s\n", modelFilename.c_str());
+            return false;
+        }
+
+        AABox modelBound;
+        bool boundEmpty=true;
+        char ident[8];
+
+        int readOperation = 1;
+
+        // temporary use defines to simplify read/check code (close file and return at fail)
+        #define READ_OR_RETURN(V,S) if(fread((V), (S), 1, rf) != 1) { \
+                                        fclose(rf); printf("readfail, op = %i\n", readOperation); return(false); }readOperation++;
+        #define CMP_OR_RETURN(V,S)  if(strcmp((V),(S)) != 0)        { \
+                                        fclose(rf); printf("cmpfail, %s!=%s\n", V, S);return(false); }
+
+        READ_OR_RETURN(&ident, 8);
+        CMP_OR_RETURN(ident, "VMAP003");
+
+        // we have to read one int. This is needed during the export and we have to skip it here
+        uint32 tempNVectors;
+        READ_OR_RETURN(&tempNVectors, sizeof(tempNVectors));
+
+        uint32 groups, wmoRootId;
+        char blockId[5];
+        blockId[4] = 0;
+        int blocksize;
+        float *vectorarray = 0;
+
+        READ_OR_RETURN(&groups, sizeof(uint32));
+        READ_OR_RETURN(&wmoRootId, sizeof(uint32));
+        if (groups != 1) printf("Warning: '%s' does not seem to be a M2 model!\n", modelFilename.c_str());
+
+        for (uint32 g=0; g<groups; ++g) // should be only one for M2 files...
+        {
+            fseek(rf, 3*sizeof(uint32) + 6*sizeof(float), SEEK_CUR);
+
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "GRP ");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            fseek(rf, blocksize, SEEK_CUR);
+
+            // ---- indexes
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "INDX");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            fseek(rf, blocksize, SEEK_CUR);
+
+            // ---- vectors
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "VERT");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            uint32 nvectors;
+            READ_OR_RETURN(&nvectors, sizeof(uint32));
+
+            if (nvectors >0)
+            {
+                vectorarray = new float[nvectors*3];
+                READ_OR_RETURN(vectorarray, nvectors*sizeof(float)*3);
+            }
+            else
+            {
+                std::cout << "error: model '" << spawn.name << "' has no geometry!" << std::endl;
+                return false;
+            }
+
+            for (uint32 i=0, indexNo=0; indexNo<nvectors; indexNo++, i+=3)
+            {
+                Vector3 v = Vector3(vectorarray[i+0], vectorarray[i+1], vectorarray[i+2]);
+                v = modelPosition.transform(v);
+
+                if (boundEmpty)
+                    modelBound = AABox(v, v), boundEmpty=false;
+                else
+                    modelBound.merge(v);
+            }
+            delete[] vectorarray;
+            // drop of temporary use defines
+            #undef READ_OR_RETURN
+            #undef CMP_OR_RETURN
+        }
+        spawn.iBound = modelBound + spawn.iPos;
+        spawn.flags |= MOD_HAS_BOUND;
+        fclose(rf);
+        return true;
+    }
+
+    struct WMOLiquidHeader
+    {
+        int xverts, yverts, xtiles, ytiles;
+        float pos_x;
+        float pos_y;
+        float pos_z;
+        short type;
+    };
+    //=================================================================
+    bool TileAssembler::convertRawFile(const std::string& pModelFilename)
+    {
+        bool success = true;
+        std::string filename = iSrcDir;
+        if (filename.length() >0)
+            filename.append("/");
+        filename.append(pModelFilename);
+        FILE *rf = fopen(filename.c_str(), "rb");
+
+        if (!rf)
+        {
+            printf("ERROR: Can't open model file in form: %s",pModelFilename.c_str());
+            printf("...                          or form: %s",filename.c_str() );
+            return false;
+        }
+
+        char ident[8];
+
+        int readOperation = 1;
+
+        // temporary use defines to simplify read/check code (close file and return at fail)
+        #define READ_OR_RETURN(V,S) if(fread((V), (S), 1, rf) != 1) { \
+                                        fclose(rf); printf("readfail, op = %i\n", readOperation); return(false); }readOperation++;
+        #define CMP_OR_RETURN(V,S)  if(strcmp((V),(S)) != 0)        { \
+                                        fclose(rf); printf("cmpfail, %s!=%s\n", V, S);return(false); }
+
+        READ_OR_RETURN(&ident, 8);
+        CMP_OR_RETURN(ident, "VMAP003");
+
+        // we have to read one int. This is needed during the export and we have to skip it here
+        uint32 tempNVectors;
+        READ_OR_RETURN(&tempNVectors, sizeof(tempNVectors));
+
+        uint32 groups;
+        uint32 RootWMOID;
+        char blockId[5];
+        blockId[4] = 0;
+        int blocksize;
+
+        READ_OR_RETURN(&groups, sizeof(uint32));
+        READ_OR_RETURN(&RootWMOID, sizeof(uint32));
+
+        std::vector<GroupModel> groupsArray;
+
+        for (uint32 g=0; g<groups; ++g)
+        {
+            std::vector<MeshTriangle> triangles;
+            std::vector<Vector3> vertexArray;
+
+            uint32 mogpflags, GroupWMOID;
+            READ_OR_RETURN(&mogpflags, sizeof(uint32));
+            READ_OR_RETURN(&GroupWMOID, sizeof(uint32));
+
+            float bbox1[3], bbox2[3];
+            READ_OR_RETURN(bbox1, sizeof(float)*3);
+            READ_OR_RETURN(bbox2, sizeof(float)*3);
+
+            uint32 liquidflags;
+            READ_OR_RETURN(&liquidflags, sizeof(uint32));
+
+            // will this ever be used? what is it good for anyway??
+            uint32 branches;
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "GRP ");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            READ_OR_RETURN(&branches, sizeof(uint32));
+            for (uint32 b=0; b<branches; ++b)
+            {
+                uint32 indexes;
+                // indexes for each branch (not used jet)
+                READ_OR_RETURN(&indexes, sizeof(uint32));
+            }
+
+            // ---- indexes
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "INDX");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            uint32 nindexes;
+            READ_OR_RETURN(&nindexes, sizeof(uint32));
+            if (nindexes >0)
+            {
+                uint16 *indexarray = new uint16[nindexes];
+                READ_OR_RETURN(indexarray, nindexes*sizeof(uint16));
+                for (uint32 i=0; i<nindexes; i+=3)
+                {
+                    triangles.push_back(MeshTriangle(indexarray[i], indexarray[i+1], indexarray[i+2]));
+                }
+                delete[] indexarray;
+            }
+
+            // ---- vectors
+            READ_OR_RETURN(&blockId, 4);
+            CMP_OR_RETURN(blockId, "VERT");
+            READ_OR_RETURN(&blocksize, sizeof(int));
+            uint32 nvectors;
+            READ_OR_RETURN(&nvectors, sizeof(uint32));
+
+            if (nvectors >0)
+            {
+                float *vectorarray = new float[nvectors*3];
+                READ_OR_RETURN(vectorarray, nvectors*sizeof(float)*3);
+                for (uint32 i=0; i<nvectors; ++i)
+                {
+                    vertexArray.push_back( Vector3(vectorarray + 3*i) );
+                }
+                delete[] vectorarray;
+            }
+            // ----- liquid
+            WmoLiquid *liquid = 0;
+            if (liquidflags& 1)
+            {
+                WMOLiquidHeader hlq;
+                READ_OR_RETURN(&blockId, 4);
+                CMP_OR_RETURN(blockId, "LIQU");
+                READ_OR_RETURN(&blocksize, sizeof(int));
+                READ_OR_RETURN(&hlq, sizeof(WMOLiquidHeader));
+                liquid = new WmoLiquid(hlq.xtiles, hlq.ytiles, Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), hlq.type);
+                uint32 size = hlq.xverts*hlq.yverts;
+                READ_OR_RETURN(liquid->GetHeightStorage(), size*sizeof(float));
+                size = hlq.xtiles*hlq.ytiles;
+                READ_OR_RETURN(liquid->GetFlagsStorage(), size);
+            }
+
+            groupsArray.push_back(GroupModel(mogpflags, GroupWMOID, AABox(Vector3(bbox1), Vector3(bbox2))));
+            groupsArray.back().setMeshData(vertexArray, triangles);
+            groupsArray.back().setLiquidData(liquid);
+
+            // drop of temporary use defines
+            #undef READ_OR_RETURN
+            #undef CMP_OR_RETURN
+
+        }
+        fclose(rf);
+
+        // write WorldModel
+        WorldModel model;
+        model.setRootWmoID(RootWMOID);
+        if (groupsArray.size())
+        {
+            model.setGroupModels(groupsArray);
+            success = model.writeFile(iDestDir + "/" + pModelFilename + ".vmo");
+        }
+
+        //std::cout << "readRawFile2: '" << pModelFilename << "' tris: " << nElements << " nodes: " << nNodes << std::endl;
+        return success;
+    }
+}
diff --git a/src/server/collision/Maps/TileAssembler.h b/src/server/collision/Maps/TileAssembler.h
new file mode 100644
index 00000000000..b26735708af
--- /dev/null
+++ b/src/server/collision/Maps/TileAssembler.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _TILEASSEMBLER_H_
+#define _TILEASSEMBLER_H_
+
+#include <G3D/Vector3.h>
+#include <G3D/Matrix3.h>
+#include <map>
+
+#include "ModelInstance.h"
+
+namespace VMAP
+{
+    /**
+    This Class is used to convert raw vector data into balanced BSP-Trees.
+    To start the conversion call convertWorld().
+    */
+    //===============================================
+
+    class ModelPosition
+    {
+        private:
+            G3D::Matrix3 iRotation;
+        public:
+            G3D::Vector3 iPos;
+            G3D::Vector3 iDir;
+            float iScale;
+            void init()
+            {
+                iRotation = G3D::Matrix3::fromEulerAnglesZYX(G3D::pi()*iDir.y/180.f, G3D::pi()*iDir.x/180.f, G3D::pi()*iDir.z/180.f);
+            }
+            G3D::Vector3 transform(const G3D::Vector3& pIn) const;
+            void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; }
+    };
+
+    typedef std::map<uint32, ModelSpawn> UniqueEntryMap;
+    typedef std::multimap<uint32, uint32> TileMap;
+
+    struct MapSpawns
+    {
+        UniqueEntryMap UniqueEntries;
+        TileMap TileEntries;
+    };
+
+    typedef std::map<uint32, MapSpawns*> MapData;
+    //===============================================
+
+    class TileAssembler
+    {
+        private:
+            std::string iDestDir;
+            std::string iSrcDir;
+            bool (*iFilterMethod)(char *pName);
+            G3D::Table<std::string, unsigned int > iUniqueNameIds;
+            unsigned int iCurrentUniqueNameId;
+            MapData mapData;
+
+        public:
+            TileAssembler(const std::string& pSrcDirName, const std::string& pDestDirName);
+            virtual ~TileAssembler();
+
+            bool convertWorld2();
+            bool readMapSpawns();
+            bool calculateTransformedBound(ModelSpawn &spawn);
+
+            bool convertRawFile(const std::string& pModelFilename);
+            void setModelNameFilterMethod(bool (*pFilterMethod)(char *pName)) { iFilterMethod = pFilterMethod; }
+            std::string getDirEntryNameFromModName(unsigned int pMapId, const std::string& pModPosName);
+            unsigned int getUniqueNameId(const std::string pName);
+    };
+
+}                                                           // VMAP
+#endif                                                      /*_TILEASSEMBLER_H_*/