Code:
// objData = our tile and the tiles bordering it
// obj = our tile
- (void)generateMeshesWithObj:(ObjData*)objData toDirectory:(NSString*)directory andX:(int)tx andY:(int)ty andTile:(ObjData*)obj andTotal:(int)totalTilesInMesh{
NSDate *start = [NSDate date];
// create our mesh loader basd on all this data (3x3 based on the tile we want the mesh for)
NSLog(@"Getting 3x3 mesh loader for (%d, %d)", tx, ty);
rcMeshLoaderObj *loader = CreateMeshLoader(objData);
if ( !loader ){
NSLog(@"Unable to create loader for (%d, %d)", tx, ty);
return;
}
InputGeom *geom = new InputGeom();
if ( !geom->loadMesh(0, loader) ){
NSLog(@"Unable to load ObjData");
return;
}
if ( !geom || !geom->getMesh() || !geom->getChunkyMesh() ){
NSLog(@"buildNavigation: Input mesh is not specified.");
return;
}
// ** Get our bounds for the tile we care about (only care about z)
NSLog(@"Getting mesh loader for (%d, %d)", tx, ty);
rcMeshLoaderObj *loader2 = CreateMeshLoader(obj);
InputGeom *geomTile = new InputGeom();
if ( !geomTile->loadMesh(0, loader2) ){
NSLog(@"Unable to load ObjData2(%d, %d)", tx, ty);
return;
}
if ( !geomTile || !geomTile->getMesh() || !geomTile->getChunkyMesh() ){
NSLog(@"buildNavigation: Input mesh is not specified.2(%d, %d)", tx, ty);
return;
}
// tile only geom
const float *bminTile = geomTile->getMeshBoundsMin();
const float *bmaxTile = geomTile->getMeshBoundsMax();
// ** End get our bounds for the tile we care about
// entire 3x3 geom
const float *bminTile2 = geom->getMeshBoundsMin();
const float *bmaxTile2 = geom->getMeshBoundsMax();
NSLog(@"-- (%d, %d) --", tx ,ty);
NSLog(@" min: {%0.2f, %0.2f, %0.2f}", bminTile2[0], bminTile2[1], bminTile2[2]);
NSLog(@" max: {%0.2f, %0.2f, %0.2f}", bmaxTile2[0], bmaxTile2[1], bmaxTile2[2]);
NSLog(@" diff: {%0.2f, %0.2f, %0.2f}", bmaxTile2[0] - bminTile2[0], bmaxTile2[1] - bminTile2[1], bmaxTile2[2] - bminTile2[2]);
// calculate the bounds of our tile! (For x,y)
float bmin_calc[3], bmax_calc[3];
bmin_calc[1] = bminTile[1];
bmax_calc[1] = bmaxTile[1];
getTileBounds(tx, ty, bmin_calc, bmax_calc);
/*NSLog(@" calculated bounds...");
NSLog(@" min: {%0.2f, %0.2f, %0.2f}", bmin_calc[0], bmin_calc[1], bmin_calc[2]);
NSLog(@" max: {%0.2f, %0.2f, %0.2f}", bmax_calc[0], bmax_calc[1], bmax_calc[2]);*/
float NavMeshOri[3];
NavMeshOri[0] = -(32 * GRID_SIZE);
NavMeshOri[1] = -(32 * GRID_SIZE);
NavMeshOri[2] = -(32 * GRID_SIZE);
//Get correct grid bounds according to our grid
float mini[3];
rcVcopy(mini, bmin_calc);
mini[0] = (tx - 32) * GRID_SIZE;
mini[2] = (ty - 32) * GRID_SIZE;
float maxi[3];
rcVcopy(maxi, bmax_calc);
maxi[0] = mini[0] + GRID_SIZE;
maxi[2] = mini[2] + GRID_SIZE;
//Div our grid
int gw = 0, gh = 0;
rcCalcGridSize(mini, maxi, CellSize, &gw, &gh);
const int ts = TileVoxelSize / GridDiv;
const int tw = (gw + ts-1) / ts;
const int th = (gh + ts-1) / ts;
const float tcs = ts * CellSize;
int numTiles = th * tw;
NavMeshSetData meshData[numTiles];
int tileNum = 0;
for(int Yi = 0; Yi < th; ++Yi){
for(int Xi = 0; Xi < tw; ++Xi){
//Get correct bound of our smaller tile
float mymini[3];
mymini[0] = mini[0] + Xi * tcs;
mymini[1] = mini[1];
mymini[2] = mini[2] + Yi * tcs;
float mymaxi[3];
mymaxi[0] = mini[0] + (Xi+1) * tcs;
mymaxi[1] = maxi[1];
mymaxi[2] = mini[2] + (Yi+1) * tcs;
//Get tile coordinates
int tileX = (int)(((mymini[0] + mymaxi[0]) / 2) - NavMeshOri[0]) / (GRID_SIZE / GridDiv);
int tileY = (int)(((mymini[2] + mymaxi[2]) / 2) - NavMeshOri[2]) / (GRID_SIZE / GridDiv);
rcCalcGridSize(mymini, mymaxi, CellSize, &gw, &gh);
NSLog(@"(%i_%i) %i_%i Grid size", tx, ty, tileX, tileY);
/*NSLog(@" tile size: %d", ts);
NSLog(@" min: {%0.2f, %0.2f, %0.2f}", mymini[0], mymini[1], mymini[2]);
NSLog(@" max: {%0.2f, %0.2f, %0.2f}", mymaxi[0], mymaxi[1], mymaxi[2]);*/
int dataSize = 0;
unsigned char *data = [self buildMeshWithGeom:geom andX:tileX andY:tileY andMin:mymini andMax:mymaxi andSize:dataSize];
if ( data ){
meshData[tileNum].data = data;
meshData[tileNum++].dataSize = dataSize;
}
int percent = int(((float)tileNum/(float)numTiles)*100.0f);
// update our statistics
[[ThreadStatController sharedInstance] setPercentComplete:percent andX:tx andY:ty];
}
}
char fileName[2048];
sprintf(fileName,"%s/%i_%i.mesh", [directory UTF8String], tx, ty);
FILE* fp = fopen(fileName, "wb");
if (!fp)
return ;
dtNavMeshParams navMeshParams;
navMeshParams.tileWidth = GRID_SIZE / GridDiv;
navMeshParams.tileHeight = GRID_SIZE / GridDiv;
navMeshParams.orig[0] = -(32 * GRID_SIZE);
navMeshParams.orig[1] = -(32 * GRID_SIZE);
navMeshParams.orig[2] = -(32 * GRID_SIZE);
navMeshParams.maxTiles = totalTilesInMesh * (GridDiv*GridDiv);
navMeshParams.maxPolys = MaxPoly;
NavMeshSetHeader header;
header.magic = NAVMESHSET_MAGIC;
header.version = NAVMESHSET_VERSION;
header.numTiles = tileNum;
memcpy(&header.params, &navMeshParams, sizeof(dtNavMeshParams));
fwrite(&header, sizeof(NavMeshSetHeader), 1, fp);
for ( int i = 0; i < tileNum; i++ ){
NavMeshTileHeader tileHeader;
tileHeader.tileRef = 0;
tileHeader.dataSize = meshData[i].dataSize;
fwrite(&tileHeader, sizeof(tileHeader), 1, fp);
fwrite(meshData[i].data, meshData[i].dataSize, 1, fp);
dtFree(meshData[i].data);
}
fclose(fp);
if ( geom ){
delete geom;
}
NSLog(@"Completed in %0.2f seconds", [start timeIntervalSinceNow] * -1.0f);
}
Note: The above is in Objective-C, but you should be able to make sense of it