NavMesh Generation - MeFisto94/jme3-recast4j-demo GitHub Wiki

Box boxMesh = new Box(20f,.1f,20f);
Geometry boxGeo = new Geometry("Colored Box", boxMesh);
Material boxMat = new Material(getApplication().getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
boxMat.setBoolean("UseMaterialColors", true);
boxMat.setColor("Ambient", ColorRGBA.LightGray);
boxMat.setColor("Diffuse", ColorRGBA.LightGray);
boxGeo.setMaterial(boxMat);
((SimpleApplication) getApplication()).getRootNode().attachChild(boxGeo);

//Step 1. Gather our geometry.
JmeInputGeomProvider geomProvider = new GeometryProviderBuilder(boxGeo).build();
//Step 2. Create a Recast configuration object. Start by creating the builder.
RecastConfigBuilder builder = new RecastConfigBuilder();
//Instantiate the configuration parameters.
RecastConfig cfg = builder
        .withAgentRadius(0.4f)              // r
        .withAgentHeight(2.0f)              // h
        //cs and ch should be .1 at min.
        .withCellSize(0.2f)                 // cs=r/2
        .withCellHeight(0.1f)               // ch=cs/2 but not < .1f
        .withAgentMaxClimb(0.3f)            // > 2*ch
        .withAgentMaxSlope(45f)
        .withEdgeMaxLen(3.2f)               // r*8
        .withEdgeMaxError(1.3f)             // 1.1 - 1.5
        .withDetailSampleDistance(6.0f)     // increase if exception
        .withDetailSampleMaxError(5.0f)     // increase if exception
        .withVertsPerPoly(3).build();
//Create a RecastBuilderConfig builder with world bounds of our geometry.
RecastBuilderConfigBuilder rcb = new RecastBuilderConfigBuilder(boxGeo);
//Build the configuration object using our cfg.
RecastBuilderConfig bcfg = rcb.withDetailMesh(true).build(cfg);
//Step 3. Build our Navmesh data using our gathered geometry and configuration.
//This is where we decide if this is a solo NavMesh build or tiled.
//Tiled will be covered later.
RecastBuilder rb = new RecastBuilder();
RecastBuilderResult rbr = rb.build(geomProvider, bcfg);
//Set the parameters needed to build our MeshData using the RecastBuilder results.
NavMeshDataCreateParamsBuilder paramBuilder = new NavMeshDataCreateParamsBuilder(rbr);
//Update poly flags from areas. Set any flags here.
PolyMesh pmesh = paramBuilder.getPolyMesh();
for (int i = 0; i < pmesh.npolys; ++i) {
    if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_GROUND
      || pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_GRASS
      || pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_ROAD) {
        paramBuilder.withPolyFlag(i, SampleAreaModifications.SAMPLE_POLYFLAGS_WALK);
    } else if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_WATER) {
        paramBuilder.withPolyFlag(i, SampleAreaModifications.SAMPLE_POLYFLAGS_SWIM);
    } else if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_DOOR) {
        paramBuilder.withPolyFlags(i, SampleAreaModifications.SAMPLE_POLYFLAGS_WALK
        | SampleAreaModifications.SAMPLE_POLYFLAGS_DOOR);
    }
}
//Build the parameter object.
NavMeshDataCreateParams params = paramBuilder.build(bcfg);
//Step 4. Generate MeshData using our parameters object.
MeshData meshData = NavMeshBuilder.createNavMeshData(params);
//Step 5. Build the NavMesh.
NavMesh navMesh = new NavMesh(meshData, bcfg.cfg.maxVertsPerPoly, 0);

try {
    //Step 6. Save our work. Using compressed format.
    MeshDataWriter mdw = new MeshDataWriter();
    mdw.write(new FileOutputStream(new File("myMeshData.md")),  meshData, ByteOrder.BIG_ENDIAN, false);
    //Or the native format using tiles.
    MeshSetWriter msw = new MeshSetWriter();
    msw.write(new FileOutputStream(new File("myNavMesh.nm")), navMesh, ByteOrder.BIG_ENDIAN, false);

    //Read in saved MeshData and build new NavMesh.
    MeshDataReader mdr = new MeshDataReader();
    MeshData savedMeshData = mdr.read(new FileInputStream("myMeshData.md"), 3);
    NavMesh navMeshFromData = new NavMesh(savedMeshData, 3, 0);
    //Or read in saved NavMesh.
    MeshSetReader msr = new MeshSetReader();
    NavMesh navMeshFromSaved = msr.read(new FileInputStream("myNavMesh.nm"), 3);
  } catch (IOException ex) {
  LOG.info("{} {}", CrowdBuilderState.class.getName(), ex);
}

//Step 1. Gather our geometry.
JmeInputGeomProvider geomProvider = new GeometryProviderBuilder(boxGeo).build();

public GeometryProviderBuilder(Mesh m)

public GeometryProviderBuilder(Geometry g)

public GeometryProviderBuilder(Node n, Predicate<Spatial> filter)

public GeometryProviderBuilder(Node n)

public RecastConfig(PartitionType partitionType, float cellSize, float cellHeight, float agentHeight,
        float agentRadius, float agentMaxClimb, float agentMaxSlope, int regionMinSize, int regionMergeSize,
        float edgeMaxLen, float edgeMaxError, int vertsPerPoly, float detailSampleDist, float detailSampleMaxError,
        int tileSize, AreaModification walkableAreaMod)

public RecastConfig build(boolean deriveValues)

/**
 * CellSize, CellHeight, AgentMaxClimb and EdgeMaxLength can be derived from
 * some formulas. Calling this method will do that for you (and thus also
 * overwrite the values manually set!)
 *
 * @return this
 */
public RecastConfigBuilder deriveValues() {
    cellSize = agentRadius / 2f; // r / 2
    cellHeight = cellSize / 2f; // cs / 2
    agentMaxClimb = 2f * cellHeight; // > 2 * ch
    edgeMaxLen = 8f * agentRadius; // r*8
    return this;
}

//Step 2. Create a Recast configuration object. Start by creating the builder.
RecastConfigBuilder builder = new RecastConfigBuilder();
//Instantiate the configuration parameters.
RecastConfig cfg = builder
        .withAgentRadius(0.4f)              // r
        .withAgentHeight(2.0f)              // h
        //cs and ch should be .1 at min.
        .withCellSize(0.2f)                 // cs=r/2
        .withCellHeight(0.1f)               // ch=cs/2 but not < .1f
        .withAgentMaxClimb(0.3f)            // > 2*ch
        .withAgentMaxSlope(45f)
        .withEdgeMaxLen(3.2f)               // r*8
        .withEdgeMaxError(1.3f)             // 1.1 - 1.5
        .withDetailSampleDistance(6.0f)     // increase if exception
        .withDetailSampleMaxError(5.0f)     // increase if exception
        .withVertsPerPoly(3).build();

//Step 3. Build our Navmesh data using our gathered geometry and configuration.
//This is where we decide if this is a solo NavMesh build or tiled.
//Tiled will be covered later.
RecastBuilder rb = new RecastBuilder();
RecastBuilderResult rbr = rb.build(geomProvider, bcfg);

//Step 4. Generate MeshData using our parameters object.
MeshData meshData = NavMeshBuilder.createNavMeshData(params);

//Step 5. Build the NavMesh.
NavMesh navMesh = new NavMesh(meshData, bcfg.cfg.maxVertsPerPoly, 0);

//Step 6. Save our work. Using compressed format.
MeshDataWriter mdw = new MeshDataWriter();
mdw.write(new FileOutputStream(new File("myMeshData.md")),  meshData, ByteOrder.BIG_ENDIAN, false);
//Or the native format using tiles.
MeshSetWriter msw = new MeshSetWriter();
msw.write(new FileOutputStream(new File("myNavMesh.nm")), navMesh, ByteOrder.BIG_ENDIAN, false);

    //Read in saved MeshData and build new NavMesh.
    MeshDataReader mdr = new MeshDataReader();
    MeshData read = mdr.read(new FileInputStream("test.md"), 3);
    NavMesh navMeshFromData = new NavMesh(read, 3, 0);

    //Or read in saved NavMesh.
    MeshSetReader msr = new MeshSetReader();
    NavMesh navMeshFromSaved = msr.read(new FileInputStream("myNavMesh.nm"), 3);

//We need to know these variables for the tile NavMeshDataCreateParams
//object.
float agentHeight = 2.0f;
float agentRadius = 0.4f;
float agentMaxClimb = 0.3f;

Box boxMesh = new Box(20f,.1f,20f);
Geometry boxGeo = new Geometry("Colored Box", boxMesh);
Material boxMat = new Material(getApplication().getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
boxMat.setBoolean("UseMaterialColors", true);
boxMat.setColor("Ambient", ColorRGBA.LightGray);
boxMat.setColor("Diffuse", ColorRGBA.LightGray);
boxGeo.setMaterial(boxMat);
((SimpleApplication) getApplication()).getRootNode().attachChild(boxGeo);

//Step 1. Gather our geometry.
JmeInputGeomProvider geomProvider = new GeometryProviderBuilder(boxGeo).build();
//Step 2. Create a Recast configuration object.
RecastConfigBuilder builder = new RecastConfigBuilder();
//Instantiate the configuration parameters.
RecastConfig cfg = builder
        .withAgentRadius(agentRadius)       // r
        .withAgentHeight(agentHeight)       // h
        //cs and ch should be .1 at min.
        .withCellSize(0.2f)                 // cs=r/2
        .withCellHeight(0.1f)               // ch=cs/2 but not < .1f
        .withAgentMaxClimb(agentMaxClimb)   // > 2*ch
        .withAgentMaxSlope(45f)
        .withEdgeMaxLen(3.2f)               // r*8
        .withEdgeMaxError(1.3f)             // 1.1 - 1.5
        .withDetailSampleDistance(6.0f)     // increase if exception
        .withDetailSampleMaxError(5.0f)     // increase if exception
        .withVertsPerPoly(3)
        .withTileSize(32).build();          // set tile size

//Build all tiles
RecastBuilder rb = new RecastBuilder();
RecastBuilderResult[][] rcResult = rb.buildTiles(geomProvider, cfg, 1);

//Set the parameters needed to build our MeshData using the RecastBuilder results.
int tw = rcResult.length;
int th = rcResult[0].length;

//Create empty nav mesh.
NavMeshParams navMeshParams = new NavMeshParams();
copy(navMeshParams.orig, geomProvider.getMeshBoundsMin());
navMeshParams.tileWidth = cfg.tileSize * cfg.cs;
navMeshParams.tileHeight = cfg.tileSize * cfg.cs;
navMeshParams.maxTiles = tw * th;
navMeshParams.maxPolys = 32768;
NavMesh navMesh = new NavMesh(navMeshParams, 3);
//Add tiles to nav mesh
for (int y = 0; y < th; y++) {
    for (int x = 0; x < tw; x++) {
        PolyMesh pmesh = rcResult[x][y].getMesh();
        if (pmesh.npolys == 0) {
                continue;
        }

        //Update poly flags from areas.
        for (int i = 0; i < pmesh.npolys; ++i) {
            if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_GROUND
                    || pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_GRASS
                    || pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_ROAD) {
                pmesh.flags[i] = SampleAreaModifications.SAMPLE_POLYFLAGS_WALK;
            } else if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_WATER) {
                pmesh.flags[i] = SampleAreaModifications.SAMPLE_POLYFLAGS_SWIM;
            } else if (pmesh.areas[i] == SampleAreaModifications.SAMPLE_POLYAREA_TYPE_DOOR) {
                pmesh.flags[i] = SampleAreaModifications.SAMPLE_POLYFLAGS_WALK
                        | SampleAreaModifications.SAMPLE_POLYFLAGS_DOOR;
            }
        }
        //Create empty parameters object to set params.
        NavMeshDataCreateParams params = new NavMeshDataCreateParams();
        params.verts = pmesh.verts;
        params.vertCount = pmesh.nverts;
        params.polys = pmesh.polys;
        params.polyAreas = pmesh.areas;
        params.polyFlags = pmesh.flags;
        params.polyCount = pmesh.npolys;
        params.nvp = pmesh.nvp;
        //Save detail mesh data.
        PolyMeshDetail dmesh = rcResult[x][y].getMeshDetail();
        params.detailMeshes = dmesh.meshes;
        params.detailVerts = dmesh.verts;
        params.detailVertsCount = dmesh.nverts;
        params.detailTris = dmesh.tris;
        params.detailTriCount = dmesh.ntris;
        params.walkableHeight = agentHeight;
        params.walkableRadius = agentRadius;
        params.walkableClimb = agentMaxClimb;
        params.bmin = pmesh.bmin;
        params.bmax = pmesh.bmax;
        params.cs = cfg.cs;
        params.ch = cfg.ch;
        params.tileX = x;
        params.tileY = y;
        params.buildBvTree = true;
        //add tile to navMesh.
        navMesh.addTile(NavMeshBuilder.createNavMeshData(params), 0, 0);
    }
}

try {
    //Native format using tiles.
    MeshSetWriter msw = new MeshSetWriter();
    msw.write(new FileOutputStream(new File("myNavMesh.nm")), navMesh, ByteOrder.BIG_ENDIAN, false);
    //Or read in saved NavMesh.
    MeshSetReader msr = new MeshSetReader();
    NavMesh navMeshFromSaved = msr.read(new FileInputStream("myNavMesh.nm"), 3);
}  catch (IOException ex) {
    LOG.info("{} {}", CrowdBuilderState.class.getName(), ex);
}

private void showDebugMeshes(MeshData meshData, boolean wireframe) {
    Material matRed = new Material(getApplication().getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
    matRed.setColor("Color", ColorRGBA.Red);

    if (wireframe) {
        matRed.getAdditionalRenderState().setWireframe(true);
    }

    Material matGreen = new Material(getApplication().getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
    matGreen.setColor("Color", ColorRGBA.Green);

    // navMesh.getTile(0).data == meshData (in this particular case)
    Geometry gDetailed = new Geometry("DebugMeshDetailed", RecastUtils.getDebugMesh(meshData.detailMeshes, meshData.detailVerts, meshData.detailTris));
    Geometry g = new Geometry("DebugMeshSimple", RecastUtils.getDebugMesh(meshData));

    g.setMaterial(matRed);
    gDetailed.setMaterial(matGreen);
    g.move(0f, 0.125f, 0f);
    gDetailed.move(0f, 0.25f, 0f);

    ((SimpleApplication) getApplication()).getRootNode().attachChild(g);
    ((SimpleApplication) getApplication()).getRootNode().attachChild(gDetailed);
}

//Step 1. Gather our geometry.
JmeInputGeomProvider geom = new GeometryProviderBuilder2(worldMap).build();

//Set offmesh connections.
offMeshCon.depthFirstTraversal(new SceneGraphVisitorAdapter() {
    //Id will be used for OffMeshConnections.
    int id = 0;

    @Override
    public void visit(Node spat) {
        /**
         * offMeshCon has no skeleton and is instance of node so the
         * search will include its children. This will return with a
         * child SkeletonControl because of this. Add check to skip
         * offMeshCon.
         */
        if (!spat.getName().equals(offMeshCon.getName())) {

            SkeletonControl skelCont = getState(UtilState.class).findControl(spat, SkeletonControl.class);

            if (skelCont != null) {
                /**
                * Offmesh connections require two connections, a
                * start/end vector3f and must connect to a surrounding
                * tile. To complete a connection, start and end must be
                * the same for each. You can supply the Vector3f manually
                * or for example, use bones from an armature. When using
                * bones, they should be paired and use a naming convention.
                *
                * In our case, we used bones and this naming convention:
                *
                * arg[0](delimiter)arg[1](delimiter)arg[2]
                *
                * We set each bone origin to any vertices, in any mesh,
                * as long as the same string for arg[0] and arg[1] are
                * identical and they do not use the same vertices. We
                * duplicate two polygons (triangles) in the mesh or
                * separate meshes and add an armature(s) using a naming
                * convention.
                *
                * Naming convention for two bones:
                *
                * Bone 1 naming: offmesh.anything.a
                * Bone 2 naming: offmesh.anything.b
                *
                * arg[0]: offmesh   = same value all bones
                * arg[1]: anything  = same value paired bones
                * arg[2]: a or b    = one paired bone
                *
                * The value of arg[0] applies to ALL bones and
                * dictates these are link bones.
                *
                * The value of arg[1] dictates these pair of bones
                * belong together.
                *
                * The value of arg[2] distinguishes the paired bones
                * from each other.
                *
                * Examples:
                *
                * offmesh.pond.a
                * offmesh.pond.b
                * offmesh.1.a
                * offmesh.1.b
                */
                Bone[] roots = skelCont.getSkeleton().getRoots();
                for (Bone b: roots) {
                    /**
                     * Split the name up using delimiter.
                     */
                    String[] arg = b.getName().split("\\.");

                    if (arg[0].equals("offmesh")) {

                        //New connection.
                        org.recast4j.detour.OffMeshConnection link1 = new org.recast4j.detour.OffMeshConnection();

                        /**
                         * The bones worldTranslation will be the start
                         * or end Vector3f of each OffMeshConnection
                         * object.
                         */
                        float[] linkPos = DetourUtils.toFloatArray(spat.localToWorld(b.getModelSpacePosition(), null));

                        /**
                         * Prepare new position array. The endpoints of
                         * the connection.
                         *
                         *  startPos    endPos
                         * [ax, ay, az, bx, by, bz]
                         */
                        float[] pos = new float[6];

                        /**
                         * Copy link1 current position to pos array. If
                         * link1 is bone (a), it becomes the link start.
                         * If (b), the link end.
                         */
                        System.arraycopy(linkPos, 0, pos, arg[2].equals("a") ? 0:3, 3);

                        //Set link1 to new array.
                        link1.pos = pos;

                        //Player (r)adius. Links fire at (r) * 2.25.
                        link1.rad = radius;

                        /**
                         * Move through link1 both directions. Only
                         * works if both links have identical in start/end.
                         * Set to 0 for one direction link.
                         */
                        link1.flags = NavMesh.DT_OFFMESH_CON_BIDIR;

                        /**
                         * We need to look for the bones mate. Based off
                         * our naming convention, this will be
                         * offmesh.anything."a" or "b" so we set the
                         * search to whatever link1 arg[2] isn't.
                         */
                        String link2 = String.join(".", arg[0], arg[1], arg[2].equals("a") ? "b": "a");

                        /**
                         * If the paired bone has already been added to
                         * map, set start or end determined by link1 arg[2].
                         */
                        if (mapOffMeshCon.containsKey(link2)) {
                            /**
                             * Copy link1 pos to link2 pos. If link1 is
                             * start(a) of link, copy link1 start to
                             * link2 start. If link1 is the end(b) of
                             * link, copy link1 end to link2 end.
                             */
                            System.arraycopy(link1.pos, arg[2].equals("a") ? 0:3, mapOffMeshCon.get(link2).pos, arg[2].equals("a") ? 0:3, 3);

                            /**
                             * Copy link2 pos to link1 pos. If link1 is
                             * the start(a) of link, copy link2 end to
                             * link1 end. If link1 is end(b) of link,
                             * copy link2 start to link1 start.
                             */
                            System.arraycopy(mapOffMeshCon.get(link2).pos, arg[2].equals("a") ? 3:0, link1.pos, arg[2].equals("a") ? 3:0, 3);

                            /**
                             * OffMeshconnections with id of 0 don't get
                             * processed later if not set here.
                             */
                            if (arg[2].equals("a")) {
                                link1.userId = ++id;
                                LOG.info("OffMeshConnection [{}] id [{}]", b.getName(), link1.userId);
                                mapOffMeshCon.get(link2).userId = ++id;
                                LOG.info("OffMeshConnection [{}] id [{}]", link2, mapOffMeshCon.get(link2).userId);
                            } else {
                                mapOffMeshCon.get(link2).userId = ++id;
                                LOG.info("OffMeshConnection [{}] id [{}]", link2, mapOffMeshCon.get(link2).userId);
                                link1.userId = ++id;
                                LOG.info("OffMeshConnection [{}] id [{}]", b.getName(), link1.userId);
                            }

                        }
                        //Add this bone to map.
                        mapOffMeshCon.put(b.getName(), link1);
                    }
                }
            }
        }
    }
});

RecastConfig rcConfig = builder
        .withAgentRadius(radius)            // r
        .withAgentHeight(height)            // h
        //cs and ch should be .1 at min.
        .withCellSize(0.1f)                 // cs=r/2
        .withCellHeight(0.1f)               // ch=cs/2 but not < .1f
        .withAgentMaxClimb(maxClimb)        // > 2*ch
        .withAgentMaxSlope(45f)
        .withEdgeMaxLen(3.2f)               // r*8
        .withEdgeMaxError(1.3f)             // 1.1 - 1.5
        .withDetailSampleDistance(6.0f)     // increase if exception
        .withDetailSampleMaxError(6.0f)     // increase if exception
        .withVertsPerPoly(3)
        .withPartitionType(PartitionType.MONOTONE)
        .withTileSize(16).build();

//Build the tile cache which also builds the navMesh.
TileCache tc = getTileCache(geom, rcConfig);

/**
 * Layers represent heights for the tile cache. For example, a bridge
 * with an underpass would have a layer for travel under the bridge and
 * another for traveling over the bridge.
 */
TileLayerBuilder layerBuilder = new TileLayerBuilder(geom, rcConfig);

List<byte[]> layers = layerBuilder.build(ByteOrder.BIG_ENDIAN, false, 1);

for (byte[] data : layers) {
    try {
        /**
         * The way tile cache works is you have two tiles, one is for
         * the cache and is added here with addTile. The other is for
         * the NavMesh and is added with buildNavMeshTile.
         */
        long ref = tc.addTile(data, 0);
        tc.buildNavMeshTile(ref);
    } catch (IOException ex) {
        LOG.error("{} {}" + NavState.class.getName(), ex);
    }
}

RecastConfig rcConfig = builder
        .withAgentRadius(radius)            // r
        .withAgentHeight(height)            // h
        //cs and ch should be .1 at min.
        .withCellSize(0.1f)                 // cs=r/2
        .withCellHeight(0.1f)               // ch=cs/2 but not < .1f
        .withAgentMaxClimb(maxClimb)        // > 2*ch
        .withAgentMaxSlope(45f)
        .withEdgeMaxLen(3.2f)               // r*8
        .withEdgeMaxError(1.3f)             // 1.1 - 1.5
        .withDetailSampleDistance(6.0f)     // increase if exception
        .withDetailSampleMaxError(6.0f)     // increase if exception
        .withVertsPerPoly(3)
        .withPartitionType(PartitionType.MONOTONE)
        .withTileSize(16).build();

//Build the tile cache which also builds the navMesh.
TileCache tc = getTileCache(geom, rcConfig);

//Build the tile cache.
private TileCache getTileCache(JmeInputGeomProvider geom, RecastConfig rcfg) {
    final int EXPECTED_LAYERS_PER_TILE = 4;

    TileCacheParams params = new TileCacheParams();

    int[] twh = Recast.calcTileCount(geom.getMeshBoundsMin(), geom.getMeshBoundsMax(), rcfg.cs, rcfg.tileSize);

    params.ch = rcfg.ch;
    params.cs = rcfg.cs;
    vCopy(params.orig, geom.getMeshBoundsMin());
    params.height = rcfg.tileSize;
    params.width = rcfg.tileSize;
    params.walkableHeight = height;
    params.walkableRadius = radius;
    params.walkableClimb = maxClimb;
    params.maxSimplificationError = rcfg.maxSimplificationError;
    params.maxTiles = twh[0] * twh[1] * EXPECTED_LAYERS_PER_TILE;
    params.maxObstacles = 128;
    NavMeshParams navMeshParams = new NavMeshParams();
    copy(navMeshParams.orig, geom.getMeshBoundsMin());
    navMeshParams.tileWidth = rcfg.tileSize * rcfg.cs;
    navMeshParams.tileHeight = rcfg.tileSize * rcfg.cs;
    navMeshParams.maxTiles = params.maxTiles;
    navMeshParams.maxPolys = 16384;
    NavMesh navMesh = new NavMesh(navMeshParams, 3);

    return new TileCache(params, new TileCacheStorageParams(ByteOrder.BIG_ENDIAN, false), navMesh, TileCacheCompressorFactory.get(false), new JmeTileCacheMeshProcess());
}

    final int EXPECTED_LAYERS_PER_TILE = 4;

params.walkableHeight = height;
params.walkableRadius = radius;
params.walkableClimb = maxClimb;

/**
 * Layers represent heights for the tile cache. For example, a bridge
 * with an underpass would have a layer for travel under the bridge and
 * another for traveling over the bridge.
 */
TileLayerBuilder layerBuilder = new TileLayerBuilder(geom, rcConfig);

List<byte[]> layers = layerBuilder.build(ByteOrder.BIG_ENDIAN, false, 1);

for (byte[] data : layers) {
    try {
        /**
         * The way tile cache works is you have two tiles, one is for
         * the cache and is added here with addTile. The other is for
         * the NavMesh and is added with buildNavMeshTile.
         */
        long ref = tc.addTile(data, 0);
        tc.buildNavMeshTile(ref);
    } catch (IOException ex) {
        LOG.error("{} {}" + NavState.class.getName(), ex);
    }
}

/**
 * This is a mandatory class otherwise the tile cache build will not set
 * the areas. This gets call from the tc.buildNavMeshTile(ref) method.
 */
protected class JmeTileCacheMeshProcess implements TileCacheMeshProcess {

    @Override
    public void process(NavMeshDataCreateParams params) {
        // Update poly flags from areas.
        for (int i = 0; i < params.polyCount; ++i) {
            Poly p = new Poly(i, 6);

            if (params.polyAreas[i] == DT_TILECACHE_WALKABLE_AREA) {
                params.polyAreas[i] = POLYAREA_TYPE_GROUND;
            }

            if (params.polyAreas[i] == POLYAREA_TYPE_GROUND
            ||  params.polyAreas[i] == POLYAREA_TYPE_GRASS
            ||  params.polyAreas[i] == POLYAREA_TYPE_ROAD) {
                params.polyFlags[i] = POLYFLAGS_WALK;
            } else if (params.polyAreas[i] == POLYAREA_TYPE_WATER) {
                params.polyFlags[i] = POLYFLAGS_SWIM;
            } else if (params.polyAreas[i] == POLYAREA_TYPE_DOOR) {
                params.polyFlags[i] = POLYFLAGS_WALK | POLYFLAGS_DOOR;
            }
        }
    }

}

//Save and read back for testing.
TileCacheWriter writer = new TileCacheWriter();
TileCacheReader reader = new TileCacheReader();

try {
    //Write our file.
    writer.write(new FileOutputStream(new File("test.tc")), tc, ByteOrder.BIG_ENDIAN, false);
    //Create new tile cache.
    tc = reader.read(new FileInputStream("test.tc"), 3, new JmeTileCacheMeshProcess());

    //Get the navMesh and build a querry object.
    navMesh = tc.getNavMesh();
    query = new NavMeshQuery(navMesh);

    /**
     * Process OffMeshConnections. Since we are reading this in we do it
     * here. If we were just running with the tile cache we first
     * created we would just place this after building the tiles.
     * Basic flow:
     * Check each mapOffMeshConnection for an index > 0.
     * findNearestPoly() for the start/end positions of the link.
     * getTileAndPolyByRef() using the returned poly reference.
     * If both start and end are good values, set the connection properties.
     */
    Iterator<Map.Entry<String, org.recast4j.detour.OffMeshConnection>> itOffMesh = mapOffMeshCon.entrySet().iterator();
    while (itOffMesh.hasNext()) {
        Map.Entry<String, org.recast4j.detour.OffMeshConnection> next = itOffMesh.next();

        /**
         * If the OffMeshConnection id is 0, there is no paired bone for the
         * link so skip.
         */
        if (next.getValue().userId > 0) {
            //Create a new filter for findNearestPoly
            DefaultQueryFilter filter = new DefaultQueryFilter();

            //In our case, we only need swim or walk flags.
            int include = POLYFLAGS_WALK | POLYFLAGS_SWIM;
            filter.setIncludeFlags(include);

            //No excludes.
            int exclude = 0;
            filter.setExcludeFlags(exclude);

            //Get the start position for the link.
            float[] startPos = new float[3];
            System.arraycopy(next.getValue().pos, 0, startPos, 0, 3);
            //Get the end position for the link.
            float[] endPos = new float[3];
            System.arraycopy(next.getValue().pos, 3, endPos, 0, 3);

            //Find the nearest polys to start/end.
            Result<FindNearestPolyResult> startPoly = query.findNearestPoly(startPos, new float[] {radius,radius,radius}, filter);
            Result<FindNearestPolyResult> endPoly = query.findNearestPoly(endPos, new float[] {radius,radius,radius}, filter);

            /**
             * Note: not isFailure() here, because isSuccess guarantees us,
             * that the result isn't "RUNNING", which it could be if we only
             * check it's not failure.
             */
            if (!startPoly.status.isSuccess()
            ||  !endPoly.status.isSuccess()
            ||   startPoly.result.getNearestRef() == 0
            ||   endPoly.result.getNearestRef() == 0) {
                LOG.error("offmeshCon findNearestPoly unsuccessful or getNearestRef is not > 0.");
                LOG.error("Link [{}] pos {} id [{}]", next.getKey(), Arrays.toString(next.getValue().pos), next.getValue().userId);
                LOG.error("findNearestPoly startPoly [{}] getNearestRef [{}]", startPoly.status.isSuccess(), startPoly.result.getNearestRef());
                LOG.error("findNearestPoly endPoly [{}] getNearestRef [{}].", endPoly.status.isSuccess(), endPoly.result.getNearestRef());
            } else {
                //Get the tile and poly from reference.
                Result<Tupple2<MeshTile, Poly>> startTileByRef = navMesh.getTileAndPolyByRef(startPoly.result.getNearestRef());
                Result<Tupple2<MeshTile, Poly>> endTileByRef = navMesh.getTileAndPolyByRef(endPoly.result.getNearestRef());

                //Mesh data for the start/end tile.
                MeshData startTile = startTileByRef.result.first.data;
                MeshData endTile = endTileByRef.result.first.data;

                //Both start and end poly must be vailid.
                if (startTileByRef.result.second != null && endTileByRef.result.second != null) {
                    //We will add a new poly that will become our "link"
                    //between start and end points so make room for it.
                    startTile.polys = Arrays.copyOf(startTile.polys, startTile.polys.length + 1);
                    //We shifted everything but haven't incremented polyCount
                    //yet so this will become our new poly's index.
                    int poly = startTile.header.polyCount;
                    /**
                     * Off-mesh connections are stored in the navigation
                     * mesh as special 2-vertex polygons with a single edge.
                     * At least one of the vertices is expected to be inside
                     * a normal polygon. So an off-mesh connection is
                     * "entered" from a normal polygon at one of its
                     * endpoints. Jme requires 3 vertices per poly to
                     * build a debug mesh so we have to create a
                     * 3-vertex polygon here if using debug. The extra
                     * vertex position will be connected automatically
                     * when we add the tile back to the navmesh. For
                     * games, this would be a two vert poly.
                     *
                     * See: https://github.com/ppiastucki/recast4j/blob/3c532068d79fe0306fedf035e50216008c306cdf/detour/src/main/java/org/recast4j/detour/NavMesh.java#L406
                     */
                    startTile.polys[poly] = new Poly(poly, 3);
                    /**
                     * Must add/create our new indices for start and end.
                     * When we add the tile, the third vert will be
                     * generated for us.
                     */
                    startTile.polys[poly].verts[0] = startTile.header.vertCount;
                    startTile.polys[poly].verts[1] = startTile.header.vertCount + 1;
                    //Set the poly's type to DT_POLYTYPE_OFFMESH_CONNECTION
                    //so it is not seen as a regular poly when linking.
                    startTile.polys[poly].setType(Poly.DT_POLYTYPE_OFFMESH_CONNECTION);
                    //Make room for our start/end verts.
                    startTile.verts = Arrays.copyOf(startTile.verts, startTile.verts.length + 6);
                    //Increment our poly and vert counts.
                    startTile.header.polyCount++;
                    startTile.header.vertCount += 2;
                    //Set our OffMeshLinks poly to this new poly.
                    next.getValue().poly = poly;
                    //Shorten names and make readable. Could just call directly.
                    float[] start = startPoly.result.getNearestPos();
                    float[] end = endPoly.result.getNearestPos();
                    //Set the links position array values to nearest.
                    next.getValue().pos = new float[] { start[0], start[1], start[2], end[0], end[1], end[2] };
                    //Determine what side of the tile the vertx is on.
                    next.getValue().side = startTile == endTile ? 0xFF
                            : NavMeshBuilder.classifyOffMeshPoint(new VectorPtr(next.getValue().pos, 3),
                                    startTile.header.bmin, startTile.header.bmax);
                    //Create new OffMeshConnection array.
                    if (startTile.offMeshCons == null) {
                            startTile.offMeshCons = new org.recast4j.detour.OffMeshConnection[1];
                    } else {
                            startTile.offMeshCons = Arrays.copyOf(startTile.offMeshCons, startTile.offMeshCons.length + 1);
                    }

                    //Add this connection.
                    startTile.offMeshCons[startTile.offMeshCons.length - 1] = next.getValue();
                    startTile.header.offMeshConCount++;

                    //Set the polys area type and flags.
                    startTile.polys[poly].flags = POLYFLAGS_JUMP;
                    startTile.polys[poly].setArea(POLYAREA_TYPE_JUMP);

                    /**
                     * Removing and adding the tile will rebuild all the
                     * links for the tile automatically. The number of links
                     * is : edges + portals * 2 + off-mesh con * 2.
                     */
                    MeshData removeTile = navMesh.removeTile(navMesh.getTileRef(startTileByRef.result.first));
                    navMesh.addTile(removeTile, 0, navMesh.getTileRef(startTileByRef.result.first));
                }
            }
        }
    }
} catch (IOException ex) {
    LOG.error("{} {}", NavState.class.getName(), ex);
}