ue-mcp 1.2.3 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/LevelHandlers_Convert.cpp

@@ -0,0 +1,316 @@
+// level(convert_brushes_to_static_mesh) (#911).
+//
+// BSP-to-StaticMesh conversion is a first-class editor operation
+// (UEditorActorSubsystem::ConvertActors) with no bridge action, so a blockout
+// pass had to be finished by hand or through Python. The wrapper is thin; the
+// work here is the safety checks, because ConvertActors DESTROYS the actors it
+// converts and there is no undo path back to a builder brush once the map is
+// saved.
+//
+// What it refuses, and why each one is a refusal rather than a warning:
+//
+//   The default builder brush. It is the editor's own scratch brush, not level
+//   geometry, and destroying it leaves the brush tools without a subject.
+//   Subtractive brushes. They carve space out of additive geometry and have no
+//   surface of their own, so converting one produces an empty mesh that looks
+//   like a successful conversion.
+//   Volumes and brush shapes. Both derive from ABrush and neither is geometry
+//   a player sees; a trigger volume converted to a StaticMeshActor is a
+//   collision change disguised as a mesh.
+//
+// Each of those can be opted into by name, which is the difference between a
+// guardrail and an obstacle.
+
+#include "LevelHandlers.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Editor.h"
+#include "Engine/Brush.h"
+#include "Components/StaticMeshComponent.h"
+#include "Engine/StaticMesh.h"
+#include "Engine/StaticMeshActor.h"
+#include "Engine/World.h"
+#include "EngineUtils.h"
+#include "GameFramework/Actor.h"
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+#include "Misc/PackageName.h"
+#include "Subsystems/EditorActorSubsystem.h"
+
+namespace
+{
+	constexpr int32 MCPConvertMaxBrushes = 500;
+
+	/** Per-brush verdict, so every candidate the selector picked is accounted
+	 *  for rather than silently dropped from the count. */
+	const TCHAR* const MCPConvertStatusEligible      = TEXT("eligible");
+	const TCHAR* const MCPConvertStatusDefaultBrush  = TEXT("skipped_default_builder_brush");
+	const TCHAR* const MCPConvertStatusSubtractive   = TEXT("skipped_subtractive");
+	const TCHAR* const MCPConvertStatusVolume        = TEXT("skipped_volume");
+	const TCHAR* const MCPConvertStatusBrushShape    = TEXT("skipped_brush_shape");
+	const TCHAR* const MCPConvertStatusNoGeometry    = TEXT("skipped_no_brush_geometry");
+	const TCHAR* const MCPConvertStatusWrongClass    = TEXT("skipped_class_filter");
+
+	struct FMCPConvertCandidate
+	{
+		ABrush* Brush = nullptr;
+		FString Label;
+		FString ClassName;
+		FString Status;
+		FVector Location = FVector::ZeroVector;
+	};
+}
+
+TSharedPtr<FJsonValue> FLevelHandlers::ConvertBrushesToStaticMesh(const TSharedPtr<FJsonObject>& Params)
+{
+	MCP_CHECK_GAME_THREAD();
+	REQUIRE_EDITOR_WORLD(World);
+
+	if (!GEditor)
+	{
+		return MCPError(TEXT("GEditor is not available"));
+	}
+	if (GEditor->PlayWorld != nullptr || GEditor->bIsSimulatingInEditor)
+	{
+		return MCPError(TEXT("Stop PIE or SIE before converting brushes"));
+	}
+
+	// ── Selection ───────────────────────────────────────────────────────────
+	TArray<FString> ActorLabels;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* LabelValues = nullptr;
+		if (Params->TryGetArrayField(TEXT("actorLabels"), LabelValues) && LabelValues)
+		{
+			ActorLabels = JsonArrayToStringList(LabelValues);
+		}
+	}
+	const FString FolderPath = OptionalString(Params, TEXT("folderPath"));
+	const bool bRecursiveFolder = OptionalBool(Params, TEXT("recursiveFolder"), true);
+	if (ActorLabels.IsEmpty() && FolderPath.IsEmpty())
+	{
+		return MCPError(TEXT("Pass 'actorLabels' or 'folderPath'. This destroys the actors it converts, so it will not run against a whole level implicitly."));
+	}
+
+	// An EXACT class filter, which is the thing the folder queries could not
+	// do: level(epic_get_actors_in_folder) has no class filter at all, so
+	// narrowing a folder to one brush class meant a get_actor_details round
+	// trip per entry (#911).
+	const FString ClassFilterSpec = OptionalString(Params, TEXT("classFilter"));
+	UClass* ClassFilter = nullptr;
+	if (!ClassFilterSpec.IsEmpty())
+	{
+		ClassFilter = MCPResolveClassOfType(ClassFilterSpec, ABrush::StaticClass(), true);
+		if (!ClassFilter)
+		{
+			return MCPClassNotFoundError(ClassFilterSpec, TEXT("classFilter"));
+		}
+	}
+	const bool bExactClass = OptionalBool(Params, TEXT("exactClass"), true);
+
+	// ── Destination ─────────────────────────────────────────────────────────
+	FString DestinationPath = OptionalString(Params, TEXT("destinationPath"), TEXT("/Game/Meshes/Converted"));
+	DestinationPath.RemoveFromEnd(TEXT("/"));
+	if (!FPackageName::IsValidLongPackageName(DestinationPath / TEXT("Probe")))
+	{
+		return MCPError(FString::Printf(
+			TEXT("'destinationPath' is not a valid content path: %s"), *DestinationPath));
+	}
+	if (DestinationPath.StartsWith(TEXT("/Engine/")) ||
+		DestinationPath.StartsWith(TEXT("/Script/")) ||
+		DestinationPath.StartsWith(TEXT("/Temp/")))
+	{
+		return MCPError(FString::Printf(
+			TEXT("'destinationPath' is outside writable project content: %s"), *DestinationPath));
+	}
+
+	// ── Safety switches ─────────────────────────────────────────────────────
+	// dryRun defaults to TRUE. Conversion destroys the source brushes, and a
+	// preview is the only chance to notice that the selector picked up a
+	// trigger volume.
+	const bool bDryRun = OptionalBool(Params, TEXT("dryRun"), true);
+	const bool bAllowSubtractive = OptionalBool(Params, TEXT("allowSubtractive"), false);
+	const bool bIncludeVolumes = OptionalBool(Params, TEXT("includeVolumes"), false);
+
+	// ── Gather ──────────────────────────────────────────────────────────────
+	ABrush* DefaultBrush = World->GetDefaultBrush();
+	TSet<FString> WantedLabels(ActorLabels);
+	TSet<FString> FoundLabels;
+	TArray<FMCPConvertCandidate> Candidates;
+
+	for (TActorIterator<ABrush> It(World); It; ++It)
+	{
+		ABrush* Brush = *It;
+		if (!Brush) continue;
+
+		const FString Label = Brush->GetActorLabel();
+		bool bSelected = false;
+		if (!WantedLabels.IsEmpty() && WantedLabels.Contains(Label))
+		{
+			bSelected = true;
+			FoundLabels.Add(Label);
+		}
+		if (!bSelected && !FolderPath.IsEmpty())
+		{
+			const FString Folder = Brush->GetFolderPath().ToString();
+			bSelected = bRecursiveFolder
+				? (Folder.Equals(FolderPath, ESearchCase::IgnoreCase) ||
+				   Folder.StartsWith(FolderPath + TEXT("/"), ESearchCase::IgnoreCase))
+				: Folder.Equals(FolderPath, ESearchCase::IgnoreCase);
+		}
+		if (!bSelected) continue;
+
+		FMCPConvertCandidate Candidate;
+		Candidate.Brush = Brush;
+		Candidate.Label = Label;
+		Candidate.ClassName = Brush->GetClass()->GetName();
+		Candidate.Location = Brush->GetActorLocation();
+
+		if (ClassFilter)
+		{
+			const bool bClassMatches = bExactClass
+				? (Brush->GetClass() == ClassFilter)
+				: Brush->IsA(ClassFilter);
+			if (!bClassMatches)
+			{
+				Candidate.Status = MCPConvertStatusWrongClass;
+				Candidates.Add(MoveTemp(Candidate));
+				continue;
+			}
+		}
+
+		if (Brush == DefaultBrush)                       Candidate.Status = MCPConvertStatusDefaultBrush;
+		else if (Brush->IsBrushShape())                  Candidate.Status = MCPConvertStatusBrushShape;
+		else if (Brush->IsVolumeBrush() && !bIncludeVolumes) Candidate.Status = MCPConvertStatusVolume;
+		else if (Brush->BrushType == Brush_Subtract && !bAllowSubtractive) Candidate.Status = MCPConvertStatusSubtractive;
+		else if (Brush->Brush == nullptr)                Candidate.Status = MCPConvertStatusNoGeometry;
+		else                                             Candidate.Status = MCPConvertStatusEligible;
+
+		Candidates.Add(MoveTemp(Candidate));
+	}
+
+	TArray<AActor*> Eligible;
+	TArray<TSharedPtr<FJsonValue>> CandidateRows;
+	TMap<FString, int32> StatusCounts;
+	for (const FMCPConvertCandidate& Candidate : Candidates)
+	{
+		++StatusCounts.FindOrAdd(Candidate.Status);
+		if (Candidate.Status == MCPConvertStatusEligible)
+		{
+			Eligible.Add(Candidate.Brush);
+		}
+		TSharedPtr<FJsonObject> Row = MakeShared<FJsonObject>();
+		Row->SetStringField(TEXT("actorLabel"), Candidate.Label);
+		Row->SetStringField(TEXT("actorClass"), Candidate.ClassName);
+		Row->SetStringField(TEXT("status"), Candidate.Status);
+		Row->SetObjectField(TEXT("location"), MCPVec3ToJsonObject(Candidate.Location));
+		CandidateRows.Add(MakeShared<FJsonValueObject>(Row));
+	}
+
+	TArray<FString> MissingLabels;
+	for (const FString& Label : ActorLabels)
+	{
+		if (!FoundLabels.Contains(Label)) MissingLabels.Add(Label);
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetBoolField(TEXT("dryRun"), bDryRun);
+	Result->SetStringField(TEXT("destinationPath"), DestinationPath);
+	Result->SetNumberField(TEXT("candidates"), Candidates.Num());
+	Result->SetNumberField(TEXT("eligible"), Eligible.Num());
+	Result->SetArrayField(TEXT("missingLabels"), MCPStringListToJson(MissingLabels));
+	Result->SetArrayField(TEXT("brushes"), CandidateRows);
+	{
+		TSharedPtr<FJsonObject> Summary = MakeShared<FJsonObject>();
+		for (const TPair<FString, int32>& Pair : StatusCounts)
+		{
+			Summary->SetNumberField(Pair.Key, Pair.Value);
+		}
+		Result->SetObjectField(TEXT("statusSummary"), Summary);
+	}
+
+	if (!MissingLabels.IsEmpty())
+	{
+		Result->SetBoolField(TEXT("success"), false);
+		Result->SetStringField(TEXT("error"), FString::Printf(
+			TEXT("%d requested label(s) matched no brush actor in this level. Note the selector only iterates ABrush actors, so a label belonging to a non-brush actor will always miss; see missingLabels."),
+			MissingLabels.Num()));
+		return MCPResult(Result);
+	}
+	if (Eligible.Num() > MCPConvertMaxBrushes)
+	{
+		Result->SetBoolField(TEXT("success"), false);
+		Result->SetStringField(TEXT("error"), FString::Printf(
+			TEXT("%d eligible brushes, over the maximum of %d for one call. Convert in folders."),
+			Eligible.Num(), MCPConvertMaxBrushes));
+		return MCPResult(Result);
+	}
+	if (Eligible.IsEmpty())
+	{
+		Result->SetStringField(TEXT("zeroMatchNote"),
+			TEXT("No brush was eligible. Read statusSummary: subtractive brushes, volumes, brush shapes and the default builder brush are excluded unless you opt in with allowSubtractive or includeVolumes."));
+		return MCPResult(Result);
+	}
+
+	if (bDryRun)
+	{
+		Result->SetNumberField(TEXT("wouldConvert"), Eligible.Num());
+		Result->SetStringField(TEXT("dryRunNote"),
+			TEXT("dryRun defaults to TRUE for this action because conversion DESTROYS the source brushes. Pass dryRun=false to commit."));
+		return MCPResult(Result);
+	}
+
+	UEditorActorSubsystem* ActorSubsystem = GEditor->GetEditorSubsystem<UEditorActorSubsystem>();
+	if (!ActorSubsystem)
+	{
+		return MCPError(TEXT("UEditorActorSubsystem is not available"));
+	}
+
+	// Record the source identity before the call, because the actors are gone
+	// afterwards and the report would otherwise be able to say only "some
+	// number of brushes used to be here".
+	TArray<FString> ConvertedFrom;
+	for (AActor* Actor : Eligible)
+	{
+		ConvertedFrom.Add(FString::Printf(TEXT("%s (%s)"), *Actor->GetActorLabel(), *Actor->GetClass()->GetName()));
+	}
+
+	const TArray<AActor*> NewActors = ActorSubsystem->ConvertActors(
+		Eligible, AStaticMeshActor::StaticClass(), DestinationPath / FString());
+
+	TArray<FString> NewLabels;
+	TArray<FString> NewMeshPaths;
+	for (AActor* Actor : NewActors)
+	{
+		if (!Actor) continue;
+		NewLabels.Add(Actor->GetActorLabel());
+		if (const AStaticMeshActor* MeshActor = Cast<AStaticMeshActor>(Actor))
+		{
+			if (const UStaticMeshComponent* Component = MeshActor->GetStaticMeshComponent())
+			{
+				if (const UStaticMesh* Mesh = Component->GetStaticMesh())
+				{
+					NewMeshPaths.AddUnique(Mesh->GetPathName());
+				}
+			}
+		}
+	}
+
+	Result->SetNumberField(TEXT("converted"), NewActors.Num());
+	Result->SetArrayField(TEXT("convertedFrom"), MCPStringListToJson(ConvertedFrom));
+	Result->SetArrayField(TEXT("newActorLabels"), MCPStringListToJson(NewLabels));
+	Result->SetArrayField(TEXT("newStaticMeshes"), MCPStringListToJson(NewMeshPaths));
+	if (NewActors.IsEmpty())
+	{
+		Result->SetBoolField(TEXT("success"), false);
+		Result->SetStringField(TEXT("error"),
+			TEXT("ConvertActors returned no new actors. The editor defers a brush conversion when it needs a destination package decision, so check whether a modal prompt is waiting in the editor window."));
+	}
+	else
+	{
+		MCPSetCreated(Result);
+		Result->SetStringField(TEXT("saveNote"),
+			TEXT("The level is left dirty and is NOT saved, and the generated static meshes are new unsaved packages. Save both when you have checked the result."));
+	}
+	return MCPResult(Result);
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/LevelHandlers_Inspection.cpp

@@ -0,0 +1,280 @@
+#include "LevelHandlers.h"
+
+#include "HandlerUtils.h"
+
+#include "Components/InstancedStaticMeshComponent.h"
+#include "Components/StaticMeshComponent.h"
+#include "Engine/StaticMesh.h"
+#include "Engine/World.h"
+#include "EngineUtils.h"
+#include "GameFramework/Actor.h"
+
+namespace
+{
+	constexpr int32 DefaultStaticMeshResults = 100;
+	constexpr int32 MaxStaticMeshResults = 500;
+	constexpr int32 HardMaxUniqueStaticMeshes = 8192;
+	constexpr int32 DefaultStaticMeshOccurrences = 32;
+	constexpr int32 MaxStaticMeshOccurrences = 256;
+
+	struct FStaticMeshAggregate
+	{
+		FString MeshPath;
+		FString LastActorPath;
+		int64 ActorCount = 0;
+		int64 ComponentCount = 0;
+		int64 PlacementCount = 0;
+	};
+
+	int64 GetPlacementCount(const UStaticMeshComponent* Component)
+	{
+		if (const UInstancedStaticMeshComponent* Instanced = Cast<UInstancedStaticMeshComponent>(Component))
+		{
+			return FMath::Max(0, Instanced->GetInstanceCount());
+		}
+
+		return 1;
+	}
+
+	void GetSortedActors(UWorld* World, TArray<AActor*>& OutActors)
+	{
+		for (TActorIterator<AActor> It(World); It; ++It)
+		{
+			if (IsValid(*It))
+			{
+				OutActors.Add(*It);
+			}
+		}
+
+		OutActors.Sort([](const AActor& Left, const AActor& Right)
+		{
+			return Left.GetPathName() < Right.GetPathName();
+		});
+	}
+
+	void GetSortedStaticMeshComponents(AActor* Actor, TArray<UStaticMeshComponent*>& OutComponents)
+	{
+		Actor->GetComponents<UStaticMeshComponent>(OutComponents);
+		OutComponents.RemoveAll([](const UStaticMeshComponent* Component)
+		{
+			return !IsValid(Component);
+		});
+		OutComponents.Sort([](const UStaticMeshComponent& Left, const UStaticMeshComponent& Right)
+		{
+			return Left.GetPathName() < Right.GetPathName();
+		});
+	}
+}
+
+TSharedPtr<FJsonValue> FLevelHandlers::SummarizeStaticMeshUsage(const TSharedPtr<FJsonObject>& Params)
+{
+	check(IsInGameThread());
+
+	const FString RequestedWorld = OptionalString(Params, TEXT("world"), TEXT("editor"));
+	const bool bEditorWorld = RequestedWorld.Equals(TEXT("editor"), ESearchCase::IgnoreCase);
+	const bool bPieWorld = RequestedWorld.Equals(TEXT("pie"), ESearchCase::IgnoreCase);
+	if (!bEditorWorld && !bPieWorld)
+	{
+		return MCPError(TEXT("Invalid 'world': expected 'editor' or 'pie'"));
+	}
+
+	const FString WorldScope = bEditorWorld ? TEXT("editor") : TEXT("pie");
+	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
+	if (!World)
+	{
+		return MCPError(FString::Printf(TEXT("World not available for scope '%s'"), *WorldScope));
+	}
+
+	const int32 MaxResults = FMath::Clamp(
+		OptionalInt(Params, TEXT("maxResults"), DefaultStaticMeshResults),
+		1,
+		MaxStaticMeshResults);
+	const bool bIncludeOccurrences = OptionalBool(Params, TEXT("includeOccurrences"), false);
+	const int32 MaxOccurrences = FMath::Clamp(
+		OptionalInt(Params, TEXT("maxOccurrences"), DefaultStaticMeshOccurrences),
+		0,
+		MaxStaticMeshOccurrences);
+
+	// Actor/component iteration order is not an API guarantee. Exact object-path
+	// ordering makes aggregation and the bounded occurrence sample reproducible.
+	TArray<AActor*> Actors;
+	GetSortedActors(World, Actors);
+
+	TMap<FString, FStaticMeshAggregate> Aggregates;
+	int64 StaticMeshActors = 0;
+	int64 ScannedStaticMeshComponents = 0;
+	int64 NullMeshComponents = 0;
+	int64 TotalComponentCount = 0;
+	int64 TotalPlacementCount = 0;
+
+	for (AActor* Actor : Actors)
+	{
+		if (!IsValid(Actor))
+		{
+			continue;
+		}
+
+		TArray<UStaticMeshComponent*> Components;
+		GetSortedStaticMeshComponents(Actor, Components);
+		if (Components.Num() > 0)
+		{
+			++StaticMeshActors;
+		}
+
+		const FString ActorPath = Actor->GetPathName();
+		for (UStaticMeshComponent* Component : Components)
+		{
+			++ScannedStaticMeshComponents;
+			UStaticMesh* Mesh = Component->GetStaticMesh();
+			if (!IsValid(Mesh))
+			{
+				++NullMeshComponents;
+				continue;
+			}
+
+			const FString MeshPath = Mesh->GetPathName();
+			FStaticMeshAggregate* Aggregate = Aggregates.Find(MeshPath);
+			if (!Aggregate)
+			{
+				if (Aggregates.Num() >= HardMaxUniqueStaticMeshes)
+				{
+					return MCPError(FString::Printf(
+						TEXT("Static mesh usage exceeds the hard limit of %d unique loaded meshes"),
+						HardMaxUniqueStaticMeshes));
+				}
+
+				FStaticMeshAggregate NewAggregate;
+				NewAggregate.MeshPath = MeshPath;
+				Aggregate = &Aggregates.Add(MeshPath, MoveTemp(NewAggregate));
+			}
+
+			const int64 PlacementCount = GetPlacementCount(Component);
+			++TotalComponentCount;
+			TotalPlacementCount += PlacementCount;
+			++Aggregate->ComponentCount;
+			Aggregate->PlacementCount += PlacementCount;
+			if (Aggregate->LastActorPath != ActorPath)
+			{
+				Aggregate->LastActorPath = ActorPath;
+				++Aggregate->ActorCount;
+			}
+		}
+	}
+
+	TArray<FString> SortedMeshPaths;
+	Aggregates.GenerateKeyArray(SortedMeshPaths);
+	SortedMeshPaths.Sort([&Aggregates](const FString& LeftPath, const FString& RightPath)
+	{
+		const FStaticMeshAggregate& Left = Aggregates.FindChecked(LeftPath);
+		const FStaticMeshAggregate& Right = Aggregates.FindChecked(RightPath);
+		if (Left.PlacementCount != Right.PlacementCount)
+		{
+			return Left.PlacementCount > Right.PlacementCount;
+		}
+		return LeftPath < RightPath;
+	});
+
+	const int32 ReturnedMeshCount = FMath::Min(MaxResults, SortedMeshPaths.Num());
+	SortedMeshPaths.SetNum(ReturnedMeshCount);
+	TSet<FString> ReturnedMeshPaths;
+	ReturnedMeshPaths.Reserve(ReturnedMeshCount);
+	for (const FString& MeshPath : SortedMeshPaths)
+	{
+		ReturnedMeshPaths.Add(MeshPath);
+	}
+
+	// Occurrences are examples, globally capped across only the returned meshes.
+	// A second deterministic pass keeps omitted aggregates from consuming the cap.
+	TMap<FString, TArray<TSharedPtr<FJsonValue>>> OccurrencesByMesh;
+	int32 ReturnedOccurrences = 0;
+	if (bIncludeOccurrences && MaxOccurrences > 0)
+	{
+		for (AActor* Actor : Actors)
+		{
+			if (!IsValid(Actor) || ReturnedOccurrences >= MaxOccurrences)
+			{
+				break;
+			}
+
+			TArray<UStaticMeshComponent*> Components;
+			GetSortedStaticMeshComponents(Actor, Components);
+			for (UStaticMeshComponent* Component : Components)
+			{
+				if (ReturnedOccurrences >= MaxOccurrences)
+				{
+					break;
+				}
+
+				UStaticMesh* Mesh = Component->GetStaticMesh();
+				if (!IsValid(Mesh) || !ReturnedMeshPaths.Contains(Mesh->GetPathName()))
+				{
+					continue;
+				}
+
+				TSharedPtr<FJsonObject> Occurrence = MakeShared<FJsonObject>();
+				Occurrence->SetStringField(TEXT("actorPath"), Actor->GetPathName());
+				Occurrence->SetStringField(TEXT("actorLabel"), Actor->GetActorLabel());
+				Occurrence->SetStringField(TEXT("componentPath"), Component->GetPathName());
+				Occurrence->SetStringField(TEXT("componentName"), Component->GetName());
+				Occurrence->SetStringField(TEXT("componentClass"), Component->GetClass()->GetPathName());
+				Occurrence->SetNumberField(TEXT("placementCount"), static_cast<double>(GetPlacementCount(Component)));
+				OccurrencesByMesh.FindOrAdd(Mesh->GetPathName()).Add(MakeShared<FJsonValueObject>(Occurrence));
+				++ReturnedOccurrences;
+			}
+		}
+	}
+
+	TArray<TSharedPtr<FJsonValue>> MeshesJson;
+	MeshesJson.Reserve(ReturnedMeshCount);
+	int64 ReturnedComponentCount = 0;
+	for (const FString& MeshPath : SortedMeshPaths)
+	{
+		const FStaticMeshAggregate& Aggregate = Aggregates.FindChecked(MeshPath);
+		ReturnedComponentCount += Aggregate.ComponentCount;
+
+		TSharedPtr<FJsonObject> MeshJson = MakeShared<FJsonObject>();
+		MeshJson->SetStringField(TEXT("meshPath"), Aggregate.MeshPath);
+		MeshJson->SetNumberField(TEXT("actorCount"), static_cast<double>(Aggregate.ActorCount));
+		MeshJson->SetNumberField(TEXT("componentCount"), static_cast<double>(Aggregate.ComponentCount));
+		MeshJson->SetNumberField(TEXT("placementCount"), static_cast<double>(Aggregate.PlacementCount));
+
+		if (bIncludeOccurrences)
+		{
+			const TArray<TSharedPtr<FJsonValue>>* Occurrences = OccurrencesByMesh.Find(MeshPath);
+			MeshJson->SetArrayField(
+				TEXT("occurrences"),
+				Occurrences ? *Occurrences : TArray<TSharedPtr<FJsonValue>>());
+			MeshJson->SetBoolField(
+				TEXT("occurrencesTruncated"),
+				!Occurrences || Occurrences->Num() < Aggregate.ComponentCount);
+		}
+
+		MeshesJson.Add(MakeShared<FJsonValueObject>(MeshJson));
+	}
+
+	TSharedPtr<FJsonObject> Result = MCPSuccess();
+	Result->SetStringField(TEXT("world"), WorldScope);
+	Result->SetStringField(TEXT("worldName"), World->GetName());
+	Result->SetBoolField(TEXT("loadedOnly"), true);
+	Result->SetNumberField(TEXT("maxResults"), MaxResults);
+	Result->SetBoolField(TEXT("includeOccurrences"), bIncludeOccurrences);
+	Result->SetNumberField(TEXT("maxOccurrences"), MaxOccurrences);
+	Result->SetNumberField(TEXT("hardUniqueMeshLimit"), HardMaxUniqueStaticMeshes);
+	Result->SetNumberField(TEXT("actorsScanned"), Actors.Num());
+	Result->SetNumberField(TEXT("staticMeshActors"), static_cast<double>(StaticMeshActors));
+	Result->SetNumberField(TEXT("scannedStaticMeshComponents"), static_cast<double>(ScannedStaticMeshComponents));
+	Result->SetNumberField(TEXT("nullMeshComponents"), static_cast<double>(NullMeshComponents));
+	Result->SetNumberField(TEXT("totalComponentCount"), static_cast<double>(TotalComponentCount));
+	Result->SetNumberField(TEXT("totalPlacementCount"), static_cast<double>(TotalPlacementCount));
+	Result->SetNumberField(TEXT("totalUniqueMeshes"), Aggregates.Num());
+	Result->SetNumberField(TEXT("returnedMeshCount"), ReturnedMeshCount);
+	Result->SetBoolField(TEXT("truncated"), ReturnedMeshCount < Aggregates.Num());
+	Result->SetNumberField(TEXT("totalOccurrences"), static_cast<double>(TotalComponentCount));
+	Result->SetNumberField(TEXT("eligibleOccurrencesForReturnedMeshes"), static_cast<double>(ReturnedComponentCount));
+	Result->SetNumberField(TEXT("returnedOccurrences"), ReturnedOccurrences);
+	Result->SetBoolField(
+		TEXT("occurrencesTruncated"),
+		bIncludeOccurrences && ReturnedOccurrences < TotalComponentCount);
+	Result->SetArrayField(TEXT("meshes"), MeshesJson);
+	return MCPResult(Result);
+}