Sometimes it's needed to export navigation mesh data to simple mesh data: vertices, edges and faces. Out of the box in Unreal Engine it's possible to export the geometry, which was used to create navigation mesh, but not the navigation mesh itself. We could use such exported mesh as an input for Houdini generators, or maybe to render the "navigable" area on a minimap.

So let's make a mesh from navigation mesh manually (kinda).

The Approach

The algorithm behind the idea is pretty straightforward:

1. Get debug mesh (also used for debug visualization) from navigation system
2. Grab all the vertices and indices of the mesh
3. Generate a new mesh using ProceduralMeshComponent from UnrealEngine
4. Save the Procedural mesh as Static Mesh

Implementation

First of all enable/check enabled Procedural Mesh Component plugin from Plugins section: Let's create Editor Utility widget class in project with a single function - export navmesh to static mesh.:

// Copyright b2soft 2024

#pragma once

#include "Editor/Blutility/Classes/EditorUtilityWidget.h"

#include "NavmeshExporterWidget.generated.h"

UCLASS(BlueprintType)
class UNavmeshExporterWidget : public UEditorUtilityWidget
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintCallable)
    void ExportNavmeshToStaticMesh();
};

To compile this we need to add UMG and Blutility to Builds.cs, also add NavigationSystem and ProceduralMeshComponent modules in advance:

PrivateDependencyModuleNames.AddRange(new[] { "Blutility", "UMG", "ProceduralMeshComponent", "NavigationSystem" });

Now we can make an actual Editor Utility Widget with one button calling the cpp function

Now the interesting part. For the Export we will use FRecastDebugGeometry struct. We shall tell it to gather polygon edges and navmesh edges. Latter are needed to find boundary vertices. Don't forget needed includes.

#include "NavmeshExporterWidget.h"

#include "AssetToolsModule.h"
#include "EditorDirectories.h"
#include "NavigationSystem.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "Dialogs/DlgPickAssetPath.h"
#include "NavMesh/RecastNavMesh.h"
#include "ProceduralMeshComponent.h"
#include "ProceduralMeshConversion.h"

Here you can find internals of ExportNavmeshToStaticMesh function:

const UNavigationSystemV1* NavSystem = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());

if (!NavSystem)
{
    return;
}

const ARecastNavMesh* NavData = Cast<ARecastNavMesh>(NavSystem->GetDefaultNavDataInstance());
if (!NavData)
{
    return;
}
FRecastDebugGeometry Geometry;
Geometry.bGatherPolyEdges = true;
Geometry.bGatherNavMeshEdges = true;

const TArray<FNavTileRef> TileSet;

NavData->BeginBatchQuery();

// Get All tiles: UE 5.5 and above
NavData->GetDebugGeometryForTile(Geometry, FNavTileRef());

NavData->FinishBatchQuery();

TSet<FVector> BoundaryVertices;
for (auto& Vertex : Geometry.NavMeshEdges)
{
    BoundaryVertices.Add(Vertex);
}

NavData->GetDebugGeometryForTile(Geometry, INDEX_NONE);

After we grabbed all the data from navigation mesh, we are ready to populate this data to Procedural Mesh Component. I apply Red color to boundary vertices, but it's completely optional, one might not need the vertex colors at all.

TArray<FVector> Vertices;
TArray<FLinearColor> VertexColors;
TArray<int32> Indices;

auto* ProcMeshComp = NewObject<UProceduralMeshComponent>();

for (int32 AreaTypeIdx = 0; AreaTypeIdx < RECAST_MAX_AREAS; ++AreaTypeIdx)
{
    auto& AreaIndices = Geometry.AreaIndices[AreaTypeIdx];

    if (AreaIndices.Num() == 0)
    {
        continue;
    }

    for (int32 VertIdx = 0; VertIdx < Geometry.MeshVerts.Num(); ++VertIdx)
    {
        Vertices.Add(Geometry.MeshVerts[VertIdx]);
        if (BoundaryVertices.Contains(Geometry.MeshVerts[VertIdx]))
        {
            VertexColors.Add(FLinearColor::Red);
        }
        else
        {
            VertexColors.Add(FLinearColor::Black);
        }
    }

    for (int32 TriIdx = 0; TriIdx < AreaIndices.Num(); TriIdx += 3)
    {
        Indices.Add(AreaIndices[TriIdx]);
        Indices.Add(AreaIndices[TriIdx + 1]);
        Indices.Add(AreaIndices[TriIdx + 2]);
    }

    ProcMeshComp->CreateMeshSection_LinearColor(ProcMeshComp->GetNumSections(),
        Vertices,
        Indices,
        {},
        {},
        VertexColors,
        {},
        false);
}

Now create the save dialog and some support stuff like suggested name:

FString NewNameSuggestion = FString(TEXT("ExportedNavMesh"));
FString DefaultPath;
const FString DefaultDirectory = FEditorDirectories::Get().GetLastDirectory(ELastDirectory::NEW_ASSET);
FPackageName::TryConvertFilenameToLongPackageName(DefaultDirectory, DefaultPath);

if (DefaultPath.IsEmpty())
{
    DefaultPath = TEXT("/Game/Meshes");
}

FString PackageName = DefaultPath / NewNameSuggestion;
FString Name;
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
AssetToolsModule.Get().CreateUniqueAssetName(PackageName, TEXT(""), PackageName, Name);

TSharedPtr<SDlgPickAssetPath> PickAssetPathWidget = SNew(SDlgPickAssetPath)
    .Title(INVTEXT("Choose NavMesh Location"))
    .DefaultAssetPath(FText::FromString(PackageName));

if (PickAssetPathWidget->ShowModal() != EAppReturnType::Ok)
{
    return;
}

And then we are ready to build Static Mesh out of ProceduralMeshCompoent:

FString UserPackageName = PickAssetPathWidget->GetFullAssetPath().ToString();
FName MeshName(*FPackageName::GetLongPackageAssetName(UserPackageName));
if (MeshName == NAME_None)
{
    UserPackageName = PackageName;
    MeshName = *Name;
}

FMeshDescription MeshDescription = BuildMeshDescription(ProcMeshComp);

if (MeshDescription.Polygons().Num() <= 0)
{
    return;
}

// Then find/create it.
UPackage* Package = CreatePackage(*UserPackageName);
check(Package);

// Create StaticMesh object
UStaticMesh* StaticMesh = NewObject<UStaticMesh>(Package, MeshName, RF_Public | RF_Standalone);
StaticMesh->InitResources();

StaticMesh->SetLightingGuid();

// Add source to new StaticMesh
FStaticMeshSourceModel& SrcModel = StaticMesh->AddSourceModel();
SrcModel.BuildSettings.bRecomputeNormals = false;
SrcModel.BuildSettings.bRecomputeTangents = false;
SrcModel.BuildSettings.bRemoveDegenerates = false;
SrcModel.BuildSettings.bUseHighPrecisionTangentBasis = false;
SrcModel.BuildSettings.bUseFullPrecisionUVs = false;
SrcModel.BuildSettings.bGenerateLightmapUVs = false;
SrcModel.BuildSettings.SrcLightmapIndex = 0;
SrcModel.BuildSettings.DstLightmapIndex = 1;
StaticMesh->CreateMeshDescription(0, MoveTemp(MeshDescription));
StaticMesh->CommitMeshDescription(0);

// No physics
StaticMesh->SetBodySetup(nullptr);

// Set the Imported version before calling the build
StaticMesh->ImportVersion = ::LastVersion;

// Adding a material slot for further usage in rendering
StaticMesh->GetStaticMaterials().Add(FStaticMaterial());

// Build mesh from source
StaticMesh->Build(false);
StaticMesh->PostEditChange();

// Notify asset registry of new asset
FAssetRegistryModule::AssetCreated(StaticMesh);

Results

Let's create a sample level: NavMeshVolume and couple of obstacles

Now pressing "Export" in our editor widget and getting the save dialog

We have our navmesh exported and saved as a Static Mesh Asset (regular static mesh)

which is exactly the navigation mesh we have:

For sure, as a bonus, RMB on asset and now you can export this mesh to FBX and use it in any tool