bool tileContains(uint32_t col, uint32_t row, uint32_t level,
double x, double y) const
{
double minx, miny, maxx, maxy;
getTileBounds(col, row, level, minx, miny, maxx, maxy);
return contains(minx, miny, maxx, maxy, x, y);
}
void MapBuilder::buildTile(int mapID, int tileX, int tileY, dtNavMesh* navMesh)
{
MeshData meshData;
// get heightmap data
m_terrainBuilder->loadMap(mapID, tileX, tileY, meshData, m_magic);
// get model data
m_terrainBuilder->loadVMap(mapID, tileY, tileX, meshData);
// if there is no data, give up now
if (!meshData.solidVerts.size() && !meshData.liquidVerts.size())
{ return; }
// remove unused vertices
TerrainBuilder::cleanVertices(meshData.solidVerts, meshData.solidTris);
TerrainBuilder::cleanVertices(meshData.liquidVerts, meshData.liquidTris);
// gather all mesh data for final data check, and bounds calculation
G3D::Array<float> allVerts;
allVerts.append(meshData.liquidVerts);
allVerts.append(meshData.solidVerts);
if (!allVerts.size())
{ return; }
// get bounds of current tile
float bmin[3], bmax[3];
getTileBounds(tileX, tileY, allVerts.getCArray(), allVerts.size() / 3, bmin, bmax);
m_terrainBuilder->loadOffMeshConnections(mapID, tileX, tileY, meshData, m_offMeshFilePath);
printf(" Building map %03u - Tile [%02u,%02u]\n", mapID, tileX, tileY);
buildMoveMapTile(mapID, tileX, tileY, meshData, bmin, bmax, navMesh);
}
void 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)
return;
if (fread(&tileX, sizeof(int), 1, file) != 1)
return;
if (fread(&tileY, sizeof(int), 1, file) != 1)
return;
dtNavMesh* navMesh = NULL;
buildNavMesh(mapId, navMesh);
if (!navMesh)
{
printf("Failed creating navmesh! \n");
fclose(file);
return;
}
uint32 verticesCount, indicesCount;
if (fread(&verticesCount, sizeof(uint32), 1, file) != 1)
return;
if (fread(&indicesCount, sizeof(uint32), 1, file) != 1)
return;
float* verts = new float[verticesCount];
int* inds = new int[indicesCount];
if (fread(verts, sizeof(float), verticesCount, file) != verticesCount)
return;
if (fread(inds, sizeof(int), indicesCount, file) != indicesCount)
return;
MeshData data;
for (uint32 i = 0; i < verticesCount; ++i)
data.solidVerts.append(verts[i]);
for (uint32 i = 0; i < indicesCount; ++i)
data.solidTris.append(inds[i]);
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
buildMoveMapTile(mapId, tileX, tileY, data, bmin, bmax, navMesh);
fclose(file);
}
void ContinentBuilder::CalculateTileBounds()
{
for (std::vector<TilePos>::iterator itr = TileMap->TileTable.begin(); itr != TileMap->TileTable.end(); ++itr)
{
tileXMax = std::max(itr->X, tileXMax);
tileXMin = std::min(itr->X, tileXMin);
tileYMax = std::max(itr->Y, tileYMax);
tileYMin = std::min(itr->Y, tileYMin);
}
getTileBounds(tileXMax, tileYMax, NULL, 0, bmin, bmax);
}
Quad getQuadrant(uint32_t col, uint32_t row, uint32_t level,
double x, double y) const
{
double minx, miny, maxx, maxy;
getTileBounds(col, row, level, minx, miny, maxx, maxy);
const double w = tileWidthAtLevel(level);
const double h = tileHeightAtLevel(level);
const double midx = minx + w/2.0;
const double midy = miny + h/2.0;
if (contains(minx, miny, midx, midy, x, y)) return QuadSW;
if (contains(midx, miny, maxx, midy, x, y)) return QuadSE;
if (contains(minx, midy, midx, maxy, x, y)) return QuadNW;
assert(contains(midx, midy, maxx, maxy, x, y));
return QuadNE;
}
void MapBuilder::buildNavMesh(uint32 mapID, dtNavMesh* &navMesh)
{
std::set<uint32>* tiles = getTileList(mapID);
// old code for non-statically assigned bitmask sizes:
///*** calculate number of bits needed to store tiles & polys ***/
//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 = STATIC_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 (std::set<uint32>::iterator it = tiles->begin(); it != tiles->end(); ++it)
{
StaticMapTree::unpackTileID(*it, 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, NULL, 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 %04u] Creating navMesh...\n", mapID);
if (!navMesh->init(&navMeshParams))
{
printf("[Map %04u] Failed creating navmesh! \n", mapID);
return;
}
char fileName[25];
sprintf(fileName, "mmaps/%04u.mmap", mapID);
FILE* file = fopen(fileName, "wb");
if (!file)
{
dtFreeNavMesh(navMesh);
char message[1024];
sprintf(message, "[Map %04u] Failed to open %s for writing!\n", mapID, fileName);
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);
}
void MapBuilder::buildNavMesh(int mapID, dtNavMesh*& navMesh, dtNavMeshParams*& navMeshParams)
{
bool isFirstNavMesh = navMeshParams ? false : true;
if (isFirstNavMesh)
{
set<uint32>* tiles = getTileList(mapID);
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 (set<uint32>::iterator it = tiles->begin(); it != tiles->end(); ++it)
{
StaticMapTree::unpackTileID((*it), 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, NULL, 0, bmin, bmax);
/*** now create the navmesh ***/
// navmesh creation params
navMeshParams = new dtNavMeshParams();
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();
if (!navMesh->init(navMeshParams))
{
printf("Failed creating navmesh! \n");
return;
}
if (isFirstNavMesh)
{
char fileName[25];
sprintf(fileName, "mmaps/%03u.mmap", mapID);
FILE* file = fopen(fileName, "wb");
if (!file)
{
dtFreeNavMesh(navMesh);
char message[1024];
sprintf(message, "Failed to open %s for writing!\n", fileName);
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);
}
}
