MMAP::MapBuilder Class Reference

#include "MapBuilder.h"

Public Member Functions
	MapBuilder (Config *config, int mapid, char const *offMeshFilePath, unsigned int threads)
	~MapBuilder ()
void	buildMeshFromFile (char *name)
void	buildSingleTile (uint32 mapID, uint32 tileX, uint32 tileY)
void	buildMaps (Optional< uint32 > mapID)
const Config &	getConfig () const

Private Member Functions
void	buildMap (uint32 mapID)
void	discoverTiles ()
std::set< uint32 > *	getTileList (uint32 mapID)
void	buildNavMesh (uint32 mapID, dtNavMesh *&navMesh)
void	getTileBounds (uint32 tileX, uint32 tileY, float *verts, int vertCount, float *bmin, float *bmax) const
void	getGridBounds (uint32 mapID, uint32 &minX, uint32 &minY, uint32 &maxX, uint32 &maxY) const
bool	shouldSkipMap (uint32 mapID) const
bool	isTransportMap (uint32 mapID) const
bool	isContinentMap (uint32 mapID) const
rcConfig	getRecastConfig (const ResolvedMeshConfig &cfg, float bmin[3], float bmax[3]) const
uint32	percentageDone (uint32 totalTiles, uint32 totalTilesDone) const
uint32	currentPercentageDone () const

Private Attributes
TerrainBuilder *	m_terrainBuilder {nullptr}
TileList	m_tiles
bool	m_debugOutput
const char *	m_offMeshFilePath
unsigned int	m_threads
bool	m_skipContinents
bool	m_skipJunkMaps
bool	m_skipBattlegrounds
bool	m_skipLiquid
int32	m_mapid
Config *	m_config
std::atomic< uint32 >	m_totalTiles
std::atomic< uint32 >	m_totalTilesProcessed
rcContext *	m_rcContext {nullptr}
std::vector< TileBuilder * >	m_tileBuilders
ProducerConsumerQueue< TileInfo >	_queue
std::atomic< bool >	_cancelationToken

Friends
class	TileBuilder

Detailed Description

Constructor & Destructor Documentation

MapBuilder()

MMAP::MapBuilder::MapBuilder	(	Config *	config,
		int	mapid,
		char const *	offMeshFilePath,
		unsigned int	threads
	)

                                                                                                       :
        m_config             (config),
        m_debugOutput        (config->IsDebugOutputEnabled()),
        m_offMeshFilePath    (offMeshFilePath),
        m_threads            (threads),
        m_skipContinents     (config->ShouldSkipContinents()),
        m_skipJunkMaps       (config->ShouldSkipJunkMaps()),
        m_skipBattlegrounds  (config->ShouldSkipBattlegrounds()),
        m_skipLiquid         (config->ShouldSkipLiquid()),
        m_mapid              (mapid),
        m_totalTiles         (0u),
        m_totalTilesProcessed(0u),
 
        _cancelationToken    (false)
    {
        m_terrainBuilder = new TerrainBuilder(config->DataDirPath(), config->ShouldSkipLiquid());
 
        m_rcContext = new rcContext(false);
 
        // At least 1 thread is needed
        m_threads = std::max(1u, m_threads);
 
        discoverTiles();
    }

References MMAP::Config::DataDirPath(), discoverTiles(), m_rcContext, m_terrainBuilder, m_threads, and MMAP::Config::ShouldSkipLiquid().

~MapBuilder()

MMAP::MapBuilder::~MapBuilder

(

)

    {
        for (auto & m_tile : m_tiles)
        {
            m_tile.m_tiles->clear();
            delete m_tile.m_tiles;
        }
 
        delete m_terrainBuilder;
        delete m_rcContext;
    }

References m_rcContext, m_terrainBuilder, and m_tiles.

Member Function Documentation

buildMap()

void MMAP::MapBuilder::buildMap ( uint32  mapID )

private

    {
        std::set<uint32>* tiles = getTileList(mapID);
 
        if (!tiles->empty())
        {
            // build navMesh
            dtNavMesh* navMesh = nullptr;
            buildNavMesh(mapID, navMesh);
            if (!navMesh)
            {
                printf("[Map %03i] Failed creating navmesh!\n", mapID);
                m_totalTilesProcessed += tiles->size();
                return;
            }
 
            // now start building mmtiles for each tile
            printf("[Map %03i] We have %u tiles.                          \n", mapID, (unsigned int)tiles->size());
            for (unsigned int tile : *tiles)
            {
                uint32 tileX, tileY;
 
                // unpack tile coords
                StaticMapTree::unpackTileID(tile, tileX, tileY);
 
                TileInfo tileInfo;
                tileInfo.m_mapId = mapID;
                tileInfo.m_tileX = tileX;
                tileInfo.m_tileY = tileY;
                memcpy(&tileInfo.m_navMeshParams, navMesh->getParams(), sizeof(dtNavMeshParams));
                _queue.Push(tileInfo);
            }
 
            dtFreeNavMesh(navMesh);
        }
    }

References _queue, buildNavMesh(), getTileList(), MMAP::TileInfo::m_mapId, MMAP::TileInfo::m_navMeshParams, MMAP::TileInfo::m_tileX, MMAP::TileInfo::m_tileY, m_totalTilesProcessed, and VMAP::StaticMapTree::unpackTileID().

Referenced by buildMaps().

buildMaps()

void MMAP::MapBuilder::buildMaps

(

Optional< uint32 >

mapID

)

    {
        printf("Using %u threads to generate mmaps\n", m_threads);
 
        for (unsigned int i = 0; i < m_threads; ++i)
        {
            m_tileBuilders.push_back(new TileBuilder(this, m_skipLiquid, m_debugOutput));
        }
 
        if (mapID)
        {
            buildMap(*mapID);
        }
        else
        {
            // Build all maps if no map id has been specified
            for (TileList::iterator it = m_tiles.begin(); it != m_tiles.end(); ++it)
            {
                if (!shouldSkipMap(it->m_mapId))
                    buildMap(it->m_mapId);
            }
        }
 
        while (!_queue.Empty())
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
 
        _cancelationToken = true;
 
        _queue.Cancel();
 
        for (auto& builder : m_tileBuilders)
            delete builder;
 
        m_tileBuilders.clear();
    }

References _cancelationToken, _queue, buildMap(), m_debugOutput, m_skipLiquid, m_threads, m_tileBuilders, m_tiles, shouldSkipMap(), and TileBuilder.

Referenced by main().

buildMeshFromFile()

void MMAP::MapBuilder::buildMeshFromFile

(

char *

name

)

    {
        FILE* file = fopen(name, "rb");
        if (!file)
            return;
 
        printf("Building mesh from file\n");
        int tileX, tileY, mapId;
        if (fread(&mapId, sizeof(int), 1, file) != 1)
        {
            fclose(file);
            return;
        }
        if (fread(&tileX, sizeof(int), 1, file) != 1)
        {
            fclose(file);
            return;
        }
        if (fread(&tileY, sizeof(int), 1, file) != 1)
        {
            fclose(file);
            return;
        }
 
        dtNavMesh* navMesh = nullptr;
        buildNavMesh(mapId, navMesh);
        if (!navMesh)
        {
            printf("Failed creating navmesh!              \n");
            fclose(file);
            return;
        }
 
        uint32 verticesCount, indicesCount;
        if (fread(&verticesCount, sizeof(uint32), 1, file) != 1)
        {
            fclose(file);
            return;
        }
 
        if (fread(&indicesCount, sizeof(uint32), 1, file) != 1)
        {
            fclose(file);
            return;
        }
 
        float* verts = new float[verticesCount];
        int* inds = new int[indicesCount];
 
        if (fread(verts, sizeof(float), verticesCount, file) != verticesCount)
        {
            fclose(file);
            delete[] verts;
            delete[] inds; // cppcheck-suppress uninitdata
            return;
        }
 
        if (fread(inds, sizeof(int), indicesCount, file) != indicesCount)
        {
            fclose(file);
            delete[] verts;
            delete[] inds;
            return;
        }
 
        MeshData data;
 
        for (uint32 i = 0; i < verticesCount; ++i)
            data.solidVerts.append(verts[i]);
        delete[] verts;
 
        for (uint32 i = 0; i < indicesCount; ++i)
            data.solidTris.append(inds[i]);
        delete[] inds;
 
        TerrainBuilder::cleanVertices(data.solidVerts, data.solidTris);
        // get bounds of current tile
        float bmin[3], bmax[3];
        getTileBounds(tileX, tileY, data.solidVerts.getCArray(), data.solidVerts.size() / 3, bmin, bmax);
 
        // build navmesh tile
        TileBuilder tileBuilder = TileBuilder(this, m_skipLiquid, m_debugOutput);
        tileBuilder.buildMoveMapTile(mapId, tileX, tileY, data, bmin, bmax, navMesh);
        fclose(file);
    }

References MMAP::TileBuilder::buildMoveMapTile(), buildNavMesh(), MMAP::TerrainBuilder::cleanVertices(), getTileBounds(), m_debugOutput, m_skipLiquid, MMAP::MeshData::solidTris, MMAP::MeshData::solidVerts, and TileBuilder.

Referenced by main().

buildNavMesh()

void MMAP::MapBuilder::buildNavMesh ( uint32  mapID, dtNavMesh *&  navMesh  )

private

‍*** calculate number of bits needed to store tiles & polys ***‍/

    {
        std::set<uint32>* tiles = getTileList(mapID);
 
        // old code for non-statically assigned bitmask sizes:
        //int tileBits = dtIlog2(dtNextPow2(tiles->size()));
        //if (tileBits < 1) tileBits = 1;                                     // need at least one bit!
        //int polyBits = sizeof(dtPolyRef)*8 - SALT_MIN_BITS - tileBits;
 
        int polyBits = DT_POLY_BITS;
 
        int maxTiles = tiles->size();
        int maxPolysPerTile = 1 << polyBits;
 
        /***          calculate bounds of map         ***/
 
        uint32 tileXMin = 64, tileYMin = 64, tileXMax = 0, tileYMax = 0, tileX, tileY;
        for (unsigned int tile : *tiles)
        {
            StaticMapTree::unpackTileID(tile, tileX, tileY);
 
            if (tileX > tileXMax)
                tileXMax = tileX;
            else if (tileX < tileXMin)
                tileXMin = tileX;
 
            if (tileY > tileYMax)
                tileYMax = tileY;
            else if (tileY < tileYMin)
                tileYMin = tileY;
        }
 
        // use Max because '32 - tileX' is negative for values over 32
        float bmin[3], bmax[3];
        getTileBounds(tileXMax, tileYMax, nullptr, 0, bmin, bmax);
 
        /***       now create the navmesh       ***/
 
        // navmesh creation params
        dtNavMeshParams navMeshParams;
        memset(&navMeshParams, 0, sizeof(dtNavMeshParams));
        navMeshParams.tileWidth = GRID_SIZE;
        navMeshParams.tileHeight = GRID_SIZE;
        rcVcopy(navMeshParams.orig, bmin);
        navMeshParams.maxTiles = maxTiles;
        navMeshParams.maxPolys = maxPolysPerTile;
 
        navMesh = dtAllocNavMesh();
        printf("[Map %03i] Creating navMesh...\n", mapID);
        if (!navMesh->init(&navMeshParams))
        {
            printf("[Map %03i] Failed creating navmesh!                \n", mapID);
            return;
        }
 
        const std::string fileName = Acore::StringFormat(
            MAP_FILE_NAME_FORMAT,
            m_config->DataDirPath(),
            mapID
        );
 
        FILE* file = fopen(fileName.c_str(), "wb");
        if (!file)
        {
            dtFreeNavMesh(navMesh);
            char message[1024];
            sprintf(message, "[Map %03i] Failed to open %s for writing!\n", mapID, fileName.c_str());
            perror(message);
            return;
        }
 
        // now that we know navMesh params are valid, we can write them to file
        fwrite(&navMeshParams, sizeof(dtNavMeshParams), 1, file);
        fclose(file);
    }

References MMAP::Config::DataDirPath(), getTileBounds(), getTileList(), MMAP::GRID_SIZE, m_config, MMAP::MAP_FILE_NAME_FORMAT, Acore::StringFormat(), and VMAP::StaticMapTree::unpackTileID().

Referenced by buildMap(), buildMeshFromFile(), and buildSingleTile().

buildSingleTile()

void MMAP::MapBuilder::buildSingleTile	(	uint32	mapID,
		uint32	tileX,
		uint32	tileY
	)

Todo:

: delete the old tile as the user clearly wants to rebuild it

    {
        dtNavMesh* navMesh = nullptr;
        buildNavMesh(mapID, navMesh);
        if (!navMesh)
        {
            printf("Failed creating navmesh!              \n");
            return;
        }
 
 
        TileBuilder tileBuilder = TileBuilder(this, m_skipLiquid, m_debugOutput);
        tileBuilder.buildTile(mapID, tileX, tileY, navMesh);
        dtFreeNavMesh(navMesh);
 
        _cancelationToken = true;
 
        _queue.Cancel();
    }

References _cancelationToken, _queue, buildNavMesh(), MMAP::TileBuilder::buildTile(), m_debugOutput, m_skipLiquid, and TileBuilder.

Referenced by main().

currentPercentageDone()

uint32 MMAP::MapBuilder::currentPercentageDone ( ) const

private

    {
        return percentageDone(m_totalTiles, m_totalTilesProcessed);
    }

References m_totalTiles, m_totalTilesProcessed, and percentageDone().

Referenced by MMAP::TileBuilder::buildTile().

discoverTiles()

void MMAP::MapBuilder::discoverTiles ( )

private

    {
        std::vector<std::string> files;
        uint32 mapID, tileX, tileY, tileID, count = 0, fsize = 0;
        char filter[12];
 
        printf("Discovering maps... ");
        getDirContents(files, m_config->MapsPath());
        for (auto & file : files)
        {
            mapID = uint32(atoi(file.substr(0, file.size() - 8).c_str()));
            if (std::find(m_tiles.begin(), m_tiles.end(), mapID) == m_tiles.end())
            {
                m_tiles.emplace_back(mapID, new std::set<uint32>);
                count++;
            }
        }
 
        files.clear();
        getDirContents(files, m_config->VMapsPath(), "*.vmtree");
        for (auto & file : files)
        {
            mapID = uint32(atoi(file.substr(0, file.size() - 7).c_str()));
            if (std::find(m_tiles.begin(), m_tiles.end(), mapID) == m_tiles.end())
            {
                m_tiles.emplace_back(mapID, new std::set<uint32>);
                count++;
            }
        }
        printf("found %u.\n", count);
 
        count = 0;
        printf("Discovering tiles... ");
        for (auto & m_tile : m_tiles)
        {
            std::set<uint32>* tiles = m_tile.m_tiles;
            mapID = m_tile.m_mapId;
 
            sprintf(filter, "%03u*.vmtile", mapID);
            files.clear();
            getDirContents(files, m_config->VMapsPath(), filter);
            for (auto & file : files)
            {
                fsize = file.size();
 
                tileY = uint32(atoi(file.substr(fsize - 12, 2).c_str()));
                tileX = uint32(atoi(file.substr(fsize - 9, 2).c_str()));
                tileID = StaticMapTree::packTileID(tileY, tileX);
 
                tiles->insert(tileID);
                count++;
            }
 
            sprintf(filter, "%03u*", mapID);
            files.clear();
            getDirContents(files, m_config->MapsPath(), filter);
            for (auto & file : files)
            {
                fsize = file.size();
 
                tileY = uint32(atoi(file.substr(fsize - 8, 2).c_str()));
                tileX = uint32(atoi(file.substr(fsize - 6, 2).c_str()));
                tileID = StaticMapTree::packTileID(tileX, tileY);
 
                if (tiles->insert(tileID).second)
                    count++;
            }
 
            // make sure we process maps which don't have tiles
            if (tiles->empty())
            {
                // convert coord bounds to grid bounds
                uint32 minX, minY, maxX, maxY;
                getGridBounds(mapID, minX, minY, maxX, maxY);
 
                // add all tiles within bounds to tile list.
                for (uint32 i = minX; i <= maxX; ++i)
                    for (uint32 j = minY; j <= maxY; ++j)
                        if (tiles->insert(StaticMapTree::packTileID(i, j)).second)
                            count++;
            }
        }
        printf("found %u.\n\n", count);
 
        // Calculate tiles to process in total
        for (auto & m_tile : m_tiles)
        {
            if (!shouldSkipMap(m_tile.m_mapId))
                m_totalTiles += m_tile.m_tiles->size();
        }
    }

References MMAP::getDirContents(), getGridBounds(), m_config, m_tiles, m_totalTiles, MMAP::Config::MapsPath(), VMAP::StaticMapTree::packTileID(), shouldSkipMap(), and MMAP::Config::VMapsPath().

Referenced by MapBuilder().

getConfig()

const Config & MMAP::MapBuilder::getConfig ( ) const

inline

{ return *m_config; }

References m_config.

Referenced by MMAP::TileBuilder::buildMoveMapTile(), MMAP::TileBuilder::shouldSkipTile(), and MMAP::TileBuilder::TileBuilder().

getGridBounds()

void MMAP::MapBuilder::getGridBounds ( uint32  mapID, uint32 &  minX, uint32 &  minY, uint32 &  maxX, uint32 &  maxY  ) const

private

    {
        // min and max are initialized to invalid values so the caller iterating the [min, max] range
        // will never enter the loop unless valid min/max values are found
        maxX = 0;
        maxY = 0;
        minX = std::numeric_limits<uint32>::max();
        minY = std::numeric_limits<uint32>::max();
 
        float bmin[3] = { 0, 0, 0 };
        float bmax[3] = { 0, 0, 0 };
        float lmin[3] = { 0, 0, 0 };
        float lmax[3] = { 0, 0, 0 };
        MeshData meshData;
 
        // make sure we process maps which don't have tiles
        // initialize the static tree, which loads WDT models
        if (!m_terrainBuilder->loadVMap(mapID, 64, 64, meshData))
            return;
 
        // get the coord bounds of the model data
        if (meshData.solidVerts.size() + meshData.liquidVerts.size() == 0)
            return;
 
        // get the coord bounds of the model data
        if (meshData.solidVerts.size() && meshData.liquidVerts.size())
        {
            rcCalcBounds(meshData.solidVerts.getCArray(), meshData.solidVerts.size() / 3, bmin, bmax);
            rcCalcBounds(meshData.liquidVerts.getCArray(), meshData.liquidVerts.size() / 3, lmin, lmax);
            rcVmin(bmin, lmin);
            rcVmax(bmax, lmax);
        }
        else if (meshData.solidVerts.size())
            rcCalcBounds(meshData.solidVerts.getCArray(), meshData.solidVerts.size() / 3, bmin, bmax);
        else
            rcCalcBounds(meshData.liquidVerts.getCArray(), meshData.liquidVerts.size() / 3, lmin, lmax);
 
        // convert coord bounds to grid bounds
        maxX = 32 - bmin[0] / GRID_SIZE;
        maxY = 32 - bmin[2] / GRID_SIZE;
        minX = 32 - bmax[0] / GRID_SIZE;
        minY = 32 - bmax[2] / GRID_SIZE;
    }

References MMAP::GRID_SIZE, MMAP::MeshData::liquidVerts, MMAP::TerrainBuilder::loadVMap(), m_terrainBuilder, and MMAP::MeshData::solidVerts.

Referenced by discoverTiles().

getRecastConfig()

rcConfig MMAP::MapBuilder::getRecastConfig ( const ResolvedMeshConfig &  cfg, float  bmin[3], float  bmax[3]  ) const

private

    {
        rcConfig config;
        memset(&config, 0, sizeof(rcConfig));
 
        rcVcopy(config.bmin, bmin);
        rcVcopy(config.bmax, bmax);
 
        config.maxVertsPerPoly = DT_VERTS_PER_POLYGON;
        config.cs = cfg.cellSizeHorizontal;
        config.ch = cfg.cellSizeVertical;
        config.walkableSlopeAngle = cfg.walkableSlopeAngle;
        config.tileSize = cfg.vertexPerTileEdge;
        config.walkableRadius = cfg.walkableRadius;
        config.borderSize = cfg.walkableRadius + 3;
        config.maxEdgeLen = cfg.vertexPerTileEdge + 1;              // anything bigger than tileSize
        config.walkableHeight = cfg.walkableHeight;
        config.walkableClimb = cfg.walkableClimb;
        config.minRegionArea = rcSqr(60);
        config.mergeRegionArea = rcSqr(50);
        config.maxSimplificationError = cfg.maxSimplificationError; // eliminates most jagged edges (tiny polygons)
        config.detailSampleDist = config.cs * 16;
        config.detailSampleMaxError = config.ch * 1;
        return config;
    }

References MMAP::ResolvedMeshConfig::cellSizeHorizontal, MMAP::ResolvedMeshConfig::cellSizeVertical, MMAP::ResolvedMeshConfig::maxSimplificationError, MMAP::ResolvedMeshConfig::vertexPerTileEdge, MMAP::ResolvedMeshConfig::walkableClimb, MMAP::ResolvedMeshConfig::walkableHeight, MMAP::ResolvedMeshConfig::walkableRadius, and MMAP::ResolvedMeshConfig::walkableSlopeAngle.

Referenced by MMAP::TileBuilder::buildMoveMapTile().

getTileBounds()

void MMAP::MapBuilder::getTileBounds ( uint32  tileX, uint32  tileY, float *  verts, int  vertCount, float *  bmin, float *  bmax  ) const

private

    {
        // this is for elevation
        if (verts && vertCount)
            rcCalcBounds(verts, vertCount, bmin, bmax);
        else
        {
            bmin[1] = FLT_MIN;
            bmax[1] = FLT_MAX;
        }
 
        // this is for width and depth
        bmax[0] = (32 - int(tileX)) * GRID_SIZE;
        bmax[2] = (32 - int(tileY)) * GRID_SIZE;
        bmin[0] = bmax[0] - GRID_SIZE;
        bmin[2] = bmax[2] - GRID_SIZE;
    }

References MMAP::GRID_SIZE.

Referenced by buildMeshFromFile(), buildNavMesh(), and MMAP::TileBuilder::buildTile().

getTileList()

std::set< uint32 > * MMAP::MapBuilder::getTileList ( uint32  mapID )

private

    {
        TileList::iterator itr = std::find(m_tiles.begin(), m_tiles.end(), mapID);
        if (itr != m_tiles.end())
            return (*itr).m_tiles;
 
        std::set<uint32>* tiles = new std::set<uint32>();
        m_tiles.emplace_back(mapID, tiles);
        return tiles;
    }

References m_tiles.

Referenced by buildMap(), and buildNavMesh().

isContinentMap()

bool MMAP::MapBuilder::isContinentMap ( uint32  mapID ) const

private

    {
        switch (mapID)
        {
            case 0:
            case 1:
            case 530:
            case 571:
                return true;
            default:
                return false;
        }
    }

Referenced by shouldSkipMap().

isTransportMap()

bool MMAP::MapBuilder::isTransportMap ( uint32  mapID ) const

private

    {
        switch (mapID)
        {
            // transport maps
            case 582:
            case 584:
            case 586:
            case 587:
            case 588:
            case 589:
            case 590:
            case 591:
            case 592:
            case 593:
            case 594:
            case 596:
            case 610:
            case 612:
            case 613:
            case 614:
            case 620:
            case 621:
            case 622:
            case 623:
            case 641:
            case 642:
            case 647:
            case 672:
            case 673:
            case 712:
            case 713:
            case 718:
                return true;
            default:
                return false;
        }
    }

Referenced by shouldSkipMap().

percentageDone()

uint32 MMAP::MapBuilder::percentageDone ( uint32  totalTiles, uint32  totalTilesDone  ) const

private

    {
        if (totalTiles)
            return totalTilesBuilt * 100 / totalTiles;
 
        return 0;
    }

Referenced by currentPercentageDone().

shouldSkipMap()

bool MMAP::MapBuilder::shouldSkipMap ( uint32  mapID ) const

private

    {
        if (m_mapid >= 0)
            return static_cast<uint32>(m_mapid) != mapID;
 
        if (m_skipContinents)
            if (isContinentMap(mapID))
                return true;
 
        if (m_skipJunkMaps)
            switch (mapID)
            {
                case 13:    // test.wdt
                case 25:    // ScottTest.wdt
                case 29:    // Test.wdt
                case 42:    // Colin.wdt
                case 169:   // EmeraldDream.wdt (unused, and very large)
                case 451:   // development.wdt
                case 573:   // ExteriorTest.wdt
                case 597:   // CraigTest.wdt
                case 605:   // development_nonweighted.wdt
                case 606:   // QA_DVD.wdt
                    return true;
                default:
                    if (isTransportMap(mapID))
                        return true;
                    break;
            }
 
        if (m_skipBattlegrounds)
            switch (mapID)
            {
                case 30:    // AV
                case 37:    // ?
                case 489:   // WSG
                case 529:   // AB
                case 566:   // EotS
                case 607:   // SotA
                case 628:   // IoC
                    return true;
                default:
                    break;
            }
 
        return false;
    }

References isContinentMap(), isTransportMap(), m_mapid, m_skipBattlegrounds, m_skipContinents, and m_skipJunkMaps.

Referenced by buildMaps(), and discoverTiles().

Friends And Related Symbol Documentation

TileBuilder

friend class TileBuilder

friend

Referenced by buildMaps(), buildMeshFromFile(), and buildSingleTile().

Member Data Documentation

_cancelationToken

std::atomic<bool> MMAP::MapBuilder::_cancelationToken

private

Referenced by buildMaps(), buildSingleTile(), and MMAP::TileBuilder::WorkerThread().

_queue

ProducerConsumerQueue<TileInfo> MMAP::MapBuilder::_queue

private

Referenced by buildMap(), buildMaps(), buildSingleTile(), and MMAP::TileBuilder::WorkerThread().

m_config

Config* MMAP::MapBuilder::m_config

private

Referenced by buildNavMesh(), discoverTiles(), and getConfig().

m_debugOutput

bool MMAP::MapBuilder::m_debugOutput

private

Referenced by buildMaps(), buildMeshFromFile(), and buildSingleTile().

m_mapid

int32 MMAP::MapBuilder::m_mapid

private

Referenced by shouldSkipMap().

m_offMeshFilePath

const char* MMAP::MapBuilder::m_offMeshFilePath

private

Referenced by MMAP::TileBuilder::buildTile().

m_rcContext

rcContext* MMAP::MapBuilder::m_rcContext {nullptr}

private

{nullptr};

Referenced by MapBuilder(), and ~MapBuilder().

m_skipBattlegrounds

bool MMAP::MapBuilder::m_skipBattlegrounds

private

Referenced by shouldSkipMap().

m_skipContinents

bool MMAP::MapBuilder::m_skipContinents

private

Referenced by shouldSkipMap().

m_skipJunkMaps

bool MMAP::MapBuilder::m_skipJunkMaps

private

Referenced by shouldSkipMap().

m_skipLiquid

bool MMAP::MapBuilder::m_skipLiquid

private

Referenced by buildMaps(), buildMeshFromFile(), and buildSingleTile().

m_terrainBuilder

TerrainBuilder* MMAP::MapBuilder::m_terrainBuilder {nullptr}

private

{nullptr};

Referenced by getGridBounds(), MapBuilder(), and ~MapBuilder().

m_threads

unsigned int MMAP::MapBuilder::m_threads

private

Referenced by buildMaps(), and MapBuilder().

m_tileBuilders

std::vector<TileBuilder*> MMAP::MapBuilder::m_tileBuilders

private

Referenced by buildMaps().

m_tiles

TileList MMAP::MapBuilder::m_tiles

private

Referenced by buildMaps(), discoverTiles(), getTileList(), and ~MapBuilder().

m_totalTiles

std::atomic<uint32> MMAP::MapBuilder::m_totalTiles

private

Referenced by currentPercentageDone(), and discoverTiles().

m_totalTilesProcessed

std::atomic<uint32> MMAP::MapBuilder::m_totalTilesProcessed

private

Referenced by buildMap(), MMAP::TileBuilder::buildTile(), and currentPercentageDone().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/tools/mmaps_generator/MapBuilder.h
• azerothcore-wotlk/src/tools/mmaps_generator/MapBuilder.cpp