Classes
class	Config

class	IMMapMgr

struct	IntermediateValues

class	MapBuilder

struct	MapTiles

struct	MeshData

struct	MMapData

class	MMapFactory

class	MMapMgr

struct	ResolvedMeshConfig

class	TerrainBuilder

struct	Tile

class	TileBuilder

struct	TileInfo

Typedefs
typedef std::unordered_map< uint32, dtTileRef >	MMapTileSet

typedef std::unordered_map< uint32, dtNavMeshQuery * >	NavMeshQuerySet

typedef std::unordered_map< uint32, MMapData * >	MMapDataSet

typedef std::list< MapTiles >	TileList

Enumerations
enum	MMAP_LOAD_RESULT { MMAP_LOAD_RESULT_ERROR , MMAP_LOAD_RESULT_OK , MMAP_LOAD_RESULT_IGNORED , MMAP_LOAD_RESULT_ERROR , MMAP_LOAD_RESULT_OK , MMAP_LOAD_RESULT_IGNORED }

enum	MMAP_LOAD_RESULT { MMAP_LOAD_RESULT_ERROR , MMAP_LOAD_RESULT_OK , MMAP_LOAD_RESULT_IGNORED , MMAP_LOAD_RESULT_ERROR , MMAP_LOAD_RESULT_OK , MMAP_LOAD_RESULT_IGNORED }

enum	ListFilesResult { LISTFILE_DIRECTORY_NOT_FOUND = 0 , LISTFILE_OK = 1 }

enum	Spot { TOP = 1 , RIGHT = 2 , LEFT = 3 , BOTTOM = 4 , ENTIRE = 5 }

enum	Grid { GRID_V8 , GRID_V9 }

Functions
float	ComputeBaseUnitDim (int vertexPerMapEdge)

std::pair< uint32, uint32 >	MakeTileKey (uint32 x, uint32 y)

bool	isCurrentDirectory (const std::string &pathStr)

std::string	executableDirectoryPath ()

bool	matchWildcardFilter (const char filter, const char str)

ListFilesResult	getDirContents (std::vector< std::string > &fileList, std::string dirpath=".", std::string filter="*")

Variables
MMapMgr *	g_MMapMgr = nullptr

static char const *const	MAP_FILE_NAME_FORMAT = "{}/mmaps/{:03}.mmap"

static char const *const	TILE_FILE_NAME_FORMAT = "{}/mmaps/{:03}{:02}{:02}.mmtile"

static char const *const	MAP_FILE_NAME_FORMAT = "{}/{:03}{:02}{:02}.map"

uint32 const	MAP_VERSION_MAGIC = 9

static uint16	holetab_h [4] = {0x1111, 0x2222, 0x4444, 0x8888}

static uint16	holetab_v [4] = {0x000F, 0x00F0, 0x0F00, 0xF000}

static const int	V9_SIZE = 129

static const int	V9_SIZE_SQ = V9_SIZE * V9_SIZE

static const int	V8_SIZE = 128

static const int	V8_SIZE_SQ = V8_SIZE * V8_SIZE

static const float	GRID_SIZE = 533.3333f

static const float	GRID_PART_SIZE = GRID_SIZE / V8_SIZE

static const float	INVALID_MAP_LIQ_HEIGHT = -500.f

static const float	INVALID_MAP_LIQ_HEIGHT_MAX = 5000.0f

Typedef Documentation

◆ MMapDataSet

typedef std::unordered_map<uint32, MMapData*> MMAP::MMapDataSet

◆ MMapTileSet

typedef std::unordered_map<uint32, dtTileRef> MMAP::MMapTileSet

◆ NavMeshQuerySet

typedef std::unordered_map<uint32, dtNavMeshQuery*> MMAP::NavMeshQuerySet

◆ TileList

typedef std::list<MapTiles> MMAP::TileList

Enumeration Type Documentation

◆ Grid

enum MMAP::Grid

Enumerator
GRID_V8
GRID_V9

    {
        GRID_V8,
        GRID_V9
    };

◆ ListFilesResult

enum MMAP::ListFilesResult

Enumerator
LISTFILE_DIRECTORY_NOT_FOUND
LISTFILE_OK

    {
        LISTFILE_DIRECTORY_NOT_FOUND = 0,
        LISTFILE_OK = 1
    };

◆ MMAP_LOAD_RESULT [1/2]

enum MMAP::MMAP_LOAD_RESULT

Enumerator
MMAP_LOAD_RESULT_ERROR
MMAP_LOAD_RESULT_OK
MMAP_LOAD_RESULT_IGNORED
MMAP_LOAD_RESULT_ERROR
MMAP_LOAD_RESULT_OK
MMAP_LOAD_RESULT_IGNORED

    {
        MMAP_LOAD_RESULT_ERROR,
        MMAP_LOAD_RESULT_OK,
        MMAP_LOAD_RESULT_IGNORED,
    };

◆ MMAP_LOAD_RESULT [2/2]

enum MMAP::MMAP_LOAD_RESULT

Enumerator
MMAP_LOAD_RESULT_ERROR
MMAP_LOAD_RESULT_OK
MMAP_LOAD_RESULT_IGNORED
MMAP_LOAD_RESULT_ERROR
MMAP_LOAD_RESULT_OK
MMAP_LOAD_RESULT_IGNORED

    {
        MMAP_LOAD_RESULT_ERROR,
        MMAP_LOAD_RESULT_OK,
        MMAP_LOAD_RESULT_IGNORED,
    };

◆ Spot

enum MMAP::Spot

Enumerator
TOP
RIGHT
LEFT
BOTTOM
ENTIRE

    {
        TOP     = 1,
        RIGHT   = 2,
        LEFT    = 3,
        BOTTOM  = 4,
        ENTIRE  = 5
    };

Function Documentation

◆ ComputeBaseUnitDim()

float MMAP::ComputeBaseUnitDim ( int vertexPerMapEdge )

    {
        return GRID_SIZE / static_cast<float>(vertexPerMapEdge);
    }

References GRID_SIZE.

Referenced by MMAP::Config::GetConfigForTile().

◆ executableDirectoryPath()

std::string MMAP::executableDirectoryPath ( )

inline

    {
        return boost::dll::program_location().parent_path().string();
    }

Referenced by handleArgs(), and MMAP::Config::LoadConfig().

◆ getDirContents()

ListFilesResult MMAP::getDirContents	(	std::vector< std::string > &	fileList,
		std::string	dirpath = `"."`,
		std::string	filter = `"*"`
	)

inline

    {
#ifdef WIN32
        HANDLE hFind;
        WIN32_FIND_DATA findFileInfo;
        std::string directory;
 
        directory = dirpath + "/" + filter;
 
        hFind = FindFirstFile(directory.c_str(), &findFileInfo);
 
        if (hFind == INVALID_HANDLE_VALUE)
            return LISTFILE_DIRECTORY_NOT_FOUND;
        do
        {
            if ((findFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
                fileList.emplace_back(findFileInfo.cFileName);
        } while (FindNextFile(hFind, &findFileInfo));
 
        FindClose(hFind);
 
#else
        const char* p = dirpath.c_str();
        DIR* dirp = opendir(p);
        struct dirent* dp;
 
        while (dirp)
        {
            errno = 0;
            if ((dp = readdir(dirp)) != nullptr)
            {
                if (matchWildcardFilter(filter.c_str(), dp->d_name))
                    fileList.emplace_back(dp->d_name);
            }
            else
                break;
        }
 
        if (dirp)
            closedir(dirp);
        else
            return LISTFILE_DIRECTORY_NOT_FOUND;
#endif
 
        return LISTFILE_OK;
    }

References LISTFILE_DIRECTORY_NOT_FOUND, LISTFILE_OK, and matchWildcardFilter().

Referenced by checkDirectories(), and MMAP::MapBuilder::discoverTiles().

◆ isCurrentDirectory()

bool MMAP::isCurrentDirectory ( const std::string & pathStr )

                                                      {
        try {
            const std::filesystem::path givenPath = std::filesystem::canonical(std::filesystem::absolute(pathStr));
            const std::filesystem::path currentPath = std::filesystem::canonical(std::filesystem::current_path());
            return givenPath == currentPath;
        } catch (const std::filesystem::filesystem_error& e) {
            std::cerr << "Filesystem error: " << e.what() << "\n";
            return false;
        }
    }

Referenced by MMAP::Config::LoadConfig().

◆ MakeTileKey()

std::pair< uint32, uint32 > MMAP::MakeTileKey	(	uint32	x,
		uint32	y
	)

    {
        return {x, y};
    }

Referenced by MMAP::Config::GetConfigForTile().

◆ matchWildcardFilter()

bool MMAP::matchWildcardFilter	(	const char *	filter,
		const char *	str
	)

inline

    {
        if (!filter || !str)
            return false;
 
        // end on null character
        while (*filter && *str)
        {
            if (*filter == '*')
            {
                if (*++filter == '\0')   // wildcard at end of filter means all remaing chars match
                    return true;
 
                for (;;)
                {
                    if (*filter == *str)
                        break;
                    if (*str == '\0')
                        return false;   // reached end of string without matching next filter character
                    str++;
                }
            }
            else if (*filter != *str)
                return false;           // mismatch
 
            filter++;
            str++;
        }
 
        return ((*filter == '\0' || (*filter == '*' && *++filter == '\0')) && *str == '\0');
    }