ue-mcp 1.2.3 → 1.3.0

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

@@ -0,0 +1,902 @@
+// Read-only mesh geometry: per-section vertex data, and mesh measurement.
+//
+// Before this existed the only way to see a vertex was execute_python calling
+// UKismetProceduralMeshLibrary.get_section_from_static_mesh, which works but
+// makes the ProceduralMeshComponent plugin a silent prerequisite for reading a
+// mesh, and returns nothing at all for a skeletal mesh. asset(get_mesh_info)
+// gives a vertex COUNT and asset(get_mesh_bounds) gives a box; neither answers
+// "where on this asset is the grip" (#926), "which triangles carry this UV
+// region" (#948) or "is this mesh watertight and how big is it" (#938).
+//
+// Both handlers read the engine's own render data - FStaticMeshLODResources for
+// a UStaticMesh, FSkeletalMeshLODRenderData for a USkeletalMesh - so there is no
+// plugin dependency and the two asset types answer through one code path.
+
+#include "AssetHandlers_Geometry.h"
+
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+
+#include "Engine/StaticMesh.h"
+#include "Engine/SkeletalMesh.h"
+// FSkeletalMaterial moved out of Engine/SkeletalMesh.h in later UE versions.
+// Pull it explicitly via SkinnedAssetCommon when available.
+#if __has_include("Engine/SkinnedAssetCommon.h")
+#include "Engine/SkinnedAssetCommon.h"
+#endif
+#include "StaticMeshResources.h"
+#include "Materials/MaterialInterface.h"
+#include "Rendering/SkeletalMeshRenderData.h"
+#include "Rendering/SkeletalMeshLODRenderData.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "HAL/FileManager.h"
+#include "Misc/FileHelper.h"
+#include "Misc/PackageName.h"
+#include "Misc/Paths.h"
+#include "Serialization/JsonSerializer.h"
+#include "Serialization/JsonWriter.h"
+
+namespace
+{
+// How many vertices one get_mesh_geometry response may carry inline. A modest
+// prop is a few thousand; a scanned asset is millions. Truncating geometry
+// would be worse than refusing it, because a partial vertex array still indexes
+// as if it were whole, so the cap is a hard stop with dumpToFile as the way
+// past it rather than a silent slice.
+constexpr int32 GeometryInlineVertexCap = 20000;
+
+// Above this triangle count the edge-adjacency pass that answers isClosed /
+// isManifold is skipped and reported as skipped. Every other metric is O(n)
+// with no allocation and stays available.
+constexpr int32 GeometryTopologyTriangleCap = 1000000;
+
+// Position quantisation used to weld vertices before topology analysis. A UV or
+// smoothing seam splits one physical vertex into several render vertices, so
+// raw index comparison reports a watertight mesh as full of boundary edges.
+constexpr float GeometryWeldTolerance = 0.01f;
+
+/** One renderable section of a LOD, described the same way for both mesh types. */
+struct FGeometrySectionInfo
+{
+	int32 SectionIndex = 0;
+	int32 MaterialIndex = 0;
+	FString MaterialSlotName;
+	FString MaterialPath;
+	uint32 FirstIndex = 0;
+	uint32 NumTriangles = 0;
+	uint32 MinVertexIndex = 0;
+	uint32 MaxVertexIndex = 0;
+	bool bDisabled = false;
+};
+
+/** Everything read off one LOD, in LOD-global vertex indexing. */
+struct FGeometrySnapshot
+{
+	FString AssetType;
+	int32 LodCount = 0;
+	int32 NumTexCoords = 0;
+	TArray<FVector3f> Positions;
+	TArray<FVector3f> Normals;
+	TArray<FVector2f> UVs;          // Only the requested channel.
+	TArray<uint32> Indices;         // Triangle list, LOD-global vertex indices.
+	TArray<FGeometrySectionInfo> Sections;
+	FBoxSphereBounds Bounds = FBoxSphereBounds(ForceInit);
+};
+
+FString GeometryMaterialPathForSlot(const UMaterialInterface* Material)
+{
+	return Material ? Material->GetPathName() : FString();
+}
+
+/** Read a static mesh LOD. Returns false with OutError set on any miss. */
+bool BuildGeometrySnapshotFromStaticMesh(
+	const UStaticMesh* Mesh,
+	int32 LodIndex,
+	int32 UVChannel,
+	bool bWantNormals,
+	bool bWantUVs,
+	FGeometrySnapshot& Out,
+	FString& OutError)
+{
+	const FStaticMeshRenderData* RenderData = Mesh->GetRenderData();
+	if (!RenderData || RenderData->LODResources.Num() == 0)
+	{
+		OutError = FString::Printf(TEXT("StaticMesh '%s' has no render data built"), *Mesh->GetPathName());
+		return false;
+	}
+
+	Out.AssetType = TEXT("StaticMesh");
+	Out.LodCount = RenderData->LODResources.Num();
+	Out.Bounds = Mesh->GetBounds();
+
+	if (LodIndex < 0 || LodIndex >= Out.LodCount)
+	{
+		OutError = FString::Printf(TEXT("lodIndex %d out of range (mesh has %d LODs)"), LodIndex, Out.LodCount);
+		return false;
+	}
+
+	const FStaticMeshLODResources& LOD = RenderData->LODResources[LodIndex];
+	const FPositionVertexBuffer& PositionBuffer = LOD.VertexBuffers.PositionVertexBuffer;
+	const FStaticMeshVertexBuffer& VertexBuffer = LOD.VertexBuffers.StaticMeshVertexBuffer;
+
+	// GetNumVertices is a count that survives the CPU copy being released, so the
+	// data pointer is what says whether the vertices are actually readable here.
+	// Editor builds keep them; a cooked, streamed build does not.
+	const int32 NumVertices = static_cast<int32>(PositionBuffer.GetNumVertices());
+	if (NumVertices == 0 || PositionBuffer.GetVertexData() == nullptr)
+	{
+		OutError = FString::Printf(TEXT("StaticMesh '%s' LOD %d has no CPU-side vertex data"), *Mesh->GetPathName(), LodIndex);
+		return false;
+	}
+
+	Out.NumTexCoords = static_cast<int32>(VertexBuffer.GetNumTexCoords());
+	if (bWantUVs && Out.NumTexCoords > 0 && (UVChannel < 0 || UVChannel >= Out.NumTexCoords))
+	{
+		OutError = FString::Printf(TEXT("uvChannel %d out of range (LOD %d has %d UV channels)"), UVChannel, LodIndex, Out.NumTexCoords);
+		return false;
+	}
+
+	Out.Positions.Reserve(NumVertices);
+	for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+	{
+		Out.Positions.Add(PositionBuffer.VertexPosition(static_cast<uint32>(VertexIndex)));
+	}
+
+	const int32 NumTangentVertices = static_cast<int32>(VertexBuffer.GetNumVertices());
+	const bool bTangentsResident = VertexBuffer.GetTangentData() != nullptr;
+	const bool bTexCoordsResident = VertexBuffer.GetTexCoordData() != nullptr;
+	if (bWantNormals && bTangentsResident && NumTangentVertices >= NumVertices)
+	{
+		Out.Normals.Reserve(NumVertices);
+		for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+		{
+			const FVector4f TangentZ = VertexBuffer.VertexTangentZ(static_cast<uint32>(VertexIndex));
+			Out.Normals.Add(FVector3f(TangentZ.X, TangentZ.Y, TangentZ.Z));
+		}
+	}
+	if (bWantUVs && Out.NumTexCoords > 0 && bTexCoordsResident && NumTangentVertices >= NumVertices)
+	{
+		Out.UVs.Reserve(NumVertices);
+		for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+		{
+			Out.UVs.Add(VertexBuffer.GetVertexUV(static_cast<uint32>(VertexIndex), static_cast<uint32>(UVChannel)));
+		}
+	}
+
+	// GetCopy memcpys from the stored indices, so ask whether they are stored,
+	// not whether the buffer was flagged for CPU access: the editor keeps the
+	// data regardless of that flag, and a cooked streamed build drops it.
+	if (LOD.IndexBuffer.GetNumIndices() > 0 && LOD.IndexBuffer.GetIndexDataSize() == 0)
+	{
+		OutError = FString::Printf(
+			TEXT("StaticMesh '%s' LOD %d index buffer has no CPU-side copy"),
+			*Mesh->GetPathName(), LodIndex);
+		return false;
+	}
+	LOD.IndexBuffer.GetCopy(Out.Indices);
+
+	const TArray<FStaticMaterial>& Materials = Mesh->GetStaticMaterials();
+	for (int32 SectionIndex = 0; SectionIndex < LOD.Sections.Num(); ++SectionIndex)
+	{
+		const FStaticMeshSection& Section = LOD.Sections[SectionIndex];
+		FGeometrySectionInfo Info;
+		Info.SectionIndex = SectionIndex;
+		Info.MaterialIndex = Section.MaterialIndex;
+		Info.FirstIndex = Section.FirstIndex;
+		Info.NumTriangles = Section.NumTriangles;
+		Info.MinVertexIndex = Section.MinVertexIndex;
+		Info.MaxVertexIndex = Section.MaxVertexIndex;
+		if (Materials.IsValidIndex(Section.MaterialIndex))
+		{
+			Info.MaterialSlotName = Materials[Section.MaterialIndex].MaterialSlotName.ToString();
+			Info.MaterialPath = GeometryMaterialPathForSlot(Materials[Section.MaterialIndex].MaterialInterface);
+		}
+		Out.Sections.Add(MoveTemp(Info));
+	}
+
+	return true;
+}
+
+/** Read a skeletal mesh LOD. Returns false with OutError set on any miss. */
+bool BuildGeometrySnapshotFromSkeletalMesh(
+	const USkeletalMesh* Mesh,
+	int32 LodIndex,
+	int32 UVChannel,
+	bool bWantNormals,
+	bool bWantUVs,
+	FGeometrySnapshot& Out,
+	FString& OutError)
+{
+	const FSkeletalMeshRenderData* RenderData = Mesh->GetResourceForRendering();
+	if (!RenderData || RenderData->LODRenderData.Num() == 0)
+	{
+		OutError = FString::Printf(TEXT("SkeletalMesh '%s' has no render data built"), *Mesh->GetPathName());
+		return false;
+	}
+
+	Out.AssetType = TEXT("SkeletalMesh");
+	Out.LodCount = RenderData->LODRenderData.Num();
+	Out.Bounds = Mesh->GetBounds();
+
+	if (LodIndex < 0 || LodIndex >= Out.LodCount)
+	{
+		OutError = FString::Printf(TEXT("lodIndex %d out of range (mesh has %d LODs)"), LodIndex, Out.LodCount);
+		return false;
+	}
+
+	const FSkeletalMeshLODRenderData& LOD = RenderData->LODRenderData[LodIndex];
+	const FPositionVertexBuffer& PositionBuffer = LOD.StaticVertexBuffers.PositionVertexBuffer;
+	const FStaticMeshVertexBuffer& VertexBuffer = LOD.StaticVertexBuffers.StaticMeshVertexBuffer;
+
+	const int32 NumVertices = static_cast<int32>(PositionBuffer.GetNumVertices());
+	if (NumVertices == 0 || PositionBuffer.GetVertexData() == nullptr)
+	{
+		OutError = FString::Printf(TEXT("SkeletalMesh '%s' LOD %d has no CPU-side vertex data"), *Mesh->GetPathName(), LodIndex);
+		return false;
+	}
+
+	Out.NumTexCoords = static_cast<int32>(VertexBuffer.GetNumTexCoords());
+	if (bWantUVs && Out.NumTexCoords > 0 && (UVChannel < 0 || UVChannel >= Out.NumTexCoords))
+	{
+		OutError = FString::Printf(TEXT("uvChannel %d out of range (LOD %d has %d UV channels)"), UVChannel, LodIndex, Out.NumTexCoords);
+		return false;
+	}
+
+	Out.Positions.Reserve(NumVertices);
+	for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+	{
+		Out.Positions.Add(PositionBuffer.VertexPosition(static_cast<uint32>(VertexIndex)));
+	}
+
+	const int32 NumTangentVertices = static_cast<int32>(VertexBuffer.GetNumVertices());
+	const bool bTangentsResident = VertexBuffer.GetTangentData() != nullptr;
+	const bool bTexCoordsResident = VertexBuffer.GetTexCoordData() != nullptr;
+	if (bWantNormals && bTangentsResident && NumTangentVertices >= NumVertices)
+	{
+		Out.Normals.Reserve(NumVertices);
+		for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+		{
+			const FVector4f TangentZ = VertexBuffer.VertexTangentZ(static_cast<uint32>(VertexIndex));
+			Out.Normals.Add(FVector3f(TangentZ.X, TangentZ.Y, TangentZ.Z));
+		}
+	}
+	if (bWantUVs && Out.NumTexCoords > 0 && bTexCoordsResident && NumTangentVertices >= NumVertices)
+	{
+		Out.UVs.Reserve(NumVertices);
+		for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
+		{
+			Out.UVs.Add(VertexBuffer.GetVertexUV(static_cast<uint32>(VertexIndex), static_cast<uint32>(UVChannel)));
+		}
+	}
+
+	if (!LOD.MultiSizeIndexContainer.IsIndexBufferValid())
+	{
+		OutError = FString::Printf(TEXT("SkeletalMesh '%s' LOD %d has no index buffer"), *Mesh->GetPathName(), LodIndex);
+		return false;
+	}
+	LOD.MultiSizeIndexContainer.GetIndexBuffer(Out.Indices);
+
+	const TArray<FSkeletalMaterial>& Materials = Mesh->GetMaterials();
+	for (int32 SectionIndex = 0; SectionIndex < LOD.RenderSections.Num(); ++SectionIndex)
+	{
+		const FSkelMeshRenderSection& Section = LOD.RenderSections[SectionIndex];
+		FGeometrySectionInfo Info;
+		Info.SectionIndex = SectionIndex;
+		Info.MaterialIndex = static_cast<int32>(Section.MaterialIndex);
+		Info.FirstIndex = Section.BaseIndex;
+		Info.NumTriangles = Section.NumTriangles;
+		Info.MinVertexIndex = Section.BaseVertexIndex;
+		Info.MaxVertexIndex = Section.NumVertices > 0
+			? Section.BaseVertexIndex + Section.NumVertices - 1
+			: Section.BaseVertexIndex;
+		Info.bDisabled = Section.bDisabled;
+		if (Materials.IsValidIndex(Info.MaterialIndex))
+		{
+			Info.MaterialSlotName = Materials[Info.MaterialIndex].MaterialSlotName.ToString();
+			Info.MaterialPath = GeometryMaterialPathForSlot(Materials[Info.MaterialIndex].MaterialInterface);
+		}
+		Out.Sections.Add(MoveTemp(Info));
+	}
+
+	return true;
+}
+
+/** Load the addressed mesh and fill a snapshot, or return the caller's error. */
+TSharedPtr<FJsonValue> BuildGeometrySnapshot(
+	const FString& AssetPath,
+	int32 LodIndex,
+	int32 UVChannel,
+	bool bWantNormals,
+	bool bWantUVs,
+	FGeometrySnapshot& Out)
+{
+	FString Error;
+
+	// Load once as UObject and branch on the concrete type. Loading twice with a
+	// typed LoadObject logs a cast failure for whichever type the asset is not,
+	// which would put a spurious warning in the editor log on every skeletal
+	// mesh read.
+	UObject* Asset = LoadAssetByPath<UObject>(AssetPath);
+	if (!Asset)
+	{
+		return MCPError(FString::Printf(TEXT("Asset not found: %s"), *AssetPath));
+	}
+
+	if (const UStaticMesh* StaticMesh = Cast<UStaticMesh>(Asset))
+	{
+		if (!BuildGeometrySnapshotFromStaticMesh(StaticMesh, LodIndex, UVChannel, bWantNormals, bWantUVs, Out, Error))
+		{
+			return MCPError(Error);
+		}
+		return nullptr;
+	}
+
+	if (const USkeletalMesh* SkeletalMesh = Cast<USkeletalMesh>(Asset))
+	{
+		if (!BuildGeometrySnapshotFromSkeletalMesh(SkeletalMesh, LodIndex, UVChannel, bWantNormals, bWantUVs, Out, Error))
+		{
+			return MCPError(Error);
+		}
+		return nullptr;
+	}
+
+	return MCPError(FString::Printf(
+		TEXT("Asset '%s' is a %s, not a StaticMesh or SkeletalMesh"),
+		*AssetPath, *Asset->GetClass()->GetName()));
+}
+
+/** Section-local triangle span, clamped to what the index buffer actually holds. */
+bool GeometrySectionTriangleRange(
+	const FGeometrySnapshot& Snapshot,
+	const FGeometrySectionInfo& Section,
+	int32& OutFirstIndex,
+	int32& OutIndexCount)
+{
+	const int64 First = static_cast<int64>(Section.FirstIndex);
+	const int64 Count = static_cast<int64>(Section.NumTriangles) * 3;
+	if (First < 0 || Count < 0 || First + Count > static_cast<int64>(Snapshot.Indices.Num()))
+	{
+		return false;
+	}
+	OutFirstIndex = static_cast<int32>(First);
+	OutIndexCount = static_cast<int32>(Count);
+	return true;
+}
+
+TSharedPtr<FJsonObject> GeometryVec3ToJson(const FVector3f& V)
+{
+	return MCPVec3ToJsonObject(FVector(V));
+}
+
+TSharedPtr<FJsonObject> GeometryUVToJson(const FVector2f& UV)
+{
+	TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+	Obj->SetNumberField(TEXT("u"), UV.X);
+	Obj->SetNumberField(TEXT("v"), UV.Y);
+	return Obj;
+}
+
+FString MakeDefaultGeometryDumpPath(const FString& AssetPath, int32 LodIndex)
+{
+	const FString AssetName = FPackageName::GetLongPackageAssetName(AssetPath);
+	const FString PathHash = FString::Printf(TEXT("%08x"), GetTypeHash(AssetPath));
+	const FString BaseName = FPaths::MakeValidFileName(
+		FString::Printf(TEXT("%s_LOD%d_%s"), *AssetName, LodIndex, *PathHash));
+	return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("UE_MCP"), TEXT("MeshGeometry"), BaseName + TEXT(".json"));
+}
+
+/** Serialise a result object to disk. Mirrors the read_blueprint_graph dump
+ *  convention: relative paths resolve under Saved/, the directory is created,
+ *  and the resolved path is echoed back. */
+bool WriteGeometryJsonToFile(
+	const TSharedPtr<FJsonObject>& JsonObject,
+	const FString& RequestedPath,
+	const FString& AssetPath,
+	int32 LodIndex,
+	FString& OutResolvedPath,
+	FString& OutError)
+{
+	OutResolvedPath = RequestedPath.IsEmpty() ? MakeDefaultGeometryDumpPath(AssetPath, LodIndex) : RequestedPath;
+	if (FPaths::IsRelative(OutResolvedPath))
+	{
+		OutResolvedPath = FPaths::Combine(FPaths::ProjectSavedDir(), OutResolvedPath);
+	}
+
+	const FString Directory = FPaths::GetPath(OutResolvedPath);
+	if (!Directory.IsEmpty() && !IFileManager::Get().MakeDirectory(*Directory, true))
+	{
+		OutError = FString::Printf(TEXT("Failed to create dump directory: %s"), *Directory);
+		return false;
+	}
+
+	FString JsonText;
+	const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&JsonText);
+	if (!FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer))
+	{
+		OutError = TEXT("Failed to serialize mesh geometry JSON");
+		return false;
+	}
+
+	if (!FFileHelper::SaveStringToFile(JsonText, *OutResolvedPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
+	{
+		OutError = FString::Printf(TEXT("Failed to write mesh geometry dump: %s"), *OutResolvedPath);
+		return false;
+	}
+
+	return true;
+}
+
+/** Welded-vertex key so a UV seam does not read as a hole. */
+struct FGeometryWeldKey
+{
+	int32 X = 0;
+	int32 Y = 0;
+	int32 Z = 0;
+
+	bool operator==(const FGeometryWeldKey& Other) const
+	{
+		return X == Other.X && Y == Other.Y && Z == Other.Z;
+	}
+};
+
+uint32 GetTypeHash(const FGeometryWeldKey& Key)
+{
+	return HashCombine(HashCombine(::GetTypeHash(Key.X), ::GetTypeHash(Key.Y)), ::GetTypeHash(Key.Z));
+}
+
+FGeometryWeldKey MakeGeometryWeldKey(const FVector3f& Position)
+{
+	FGeometryWeldKey Key;
+	Key.X = FMath::RoundToInt(Position.X / GeometryWeldTolerance);
+	Key.Y = FMath::RoundToInt(Position.Y / GeometryWeldTolerance);
+	Key.Z = FMath::RoundToInt(Position.Z / GeometryWeldTolerance);
+	return Key;
+}
+}
+
+
+void FAssetGeometryHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	Registry.RegisterHandler(TEXT("get_mesh_geometry"), &GetMeshGeometry);
+	Registry.RegisterHandler(TEXT("measure_mesh_geometry"), &MeasureMeshGeometry);
+}
+
+
+TSharedPtr<FJsonValue> FAssetGeometryHandlers::GetMeshGeometry(const TSharedPtr<FJsonObject>& Params)
+{
+	FString AssetPath;
+	if (auto Err = RequireStringAlt(Params, TEXT("assetPath"), TEXT("path"), AssetPath)) return Err;
+
+	const int32 LodIndex = OptionalInt(Params, TEXT("lodIndex"), 0);
+	const int32 UVChannel = OptionalInt(Params, TEXT("uvChannel"), 0);
+	const bool bDumpToFile = OptionalBool(Params, TEXT("dumpToFile"), false);
+	const FString OutputPath = OptionalString(Params, TEXT("outputPath"), TEXT(""));
+
+	const bool bHasSectionIndex = Params->HasField(TEXT("sectionIndex"));
+	const int32 RequestedSection = OptionalInt(Params, TEXT("sectionIndex"), 0);
+
+	// `include` selects which arrays come back. Omitted means all four, which is
+	// what a caller who does not know what they need should get.
+	bool bWantPositions = true;
+	bool bWantUVs = true;
+	bool bWantNormals = true;
+	bool bWantTriangles = true;
+	const TArray<TSharedPtr<FJsonValue>>* IncludeArray = nullptr;
+	if (Params->TryGetArrayField(TEXT("include"), IncludeArray) && IncludeArray)
+	{
+		bWantPositions = bWantUVs = bWantNormals = bWantTriangles = false;
+		for (const TSharedPtr<FJsonValue>& Entry : *IncludeArray)
+		{
+			if (!Entry.IsValid()) continue;
+			const FString Token = Entry->AsString().ToLower();
+			if (Token == TEXT("positions")) bWantPositions = true;
+			else if (Token == TEXT("uvs")) bWantUVs = true;
+			else if (Token == TEXT("normals")) bWantNormals = true;
+			else if (Token == TEXT("triangles")) bWantTriangles = true;
+			else
+			{
+				return MCPError(FString::Printf(
+					TEXT("include entry '%s' is not one of: positions, uvs, normals, triangles"),
+					*Entry->AsString()));
+			}
+		}
+		if (!bWantPositions && !bWantUVs && !bWantNormals && !bWantTriangles)
+		{
+			return MCPError(TEXT("'include' was empty: pass at least one of positions, uvs, normals, triangles"));
+		}
+	}
+
+	FGeometrySnapshot Snapshot;
+	if (auto Err = BuildGeometrySnapshot(AssetPath, LodIndex, UVChannel, bWantNormals, bWantUVs, Snapshot))
+	{
+		return Err;
+	}
+
+	TArray<int32> SectionsToEmit;
+	if (bHasSectionIndex)
+	{
+		if (!Snapshot.Sections.IsValidIndex(RequestedSection))
+		{
+			return MCPError(FString::Printf(
+				TEXT("sectionIndex %d out of range (LOD %d has %d sections)"),
+				RequestedSection, LodIndex, Snapshot.Sections.Num()));
+		}
+		SectionsToEmit.Add(RequestedSection);
+	}
+	else
+	{
+		for (int32 Index = 0; Index < Snapshot.Sections.Num(); ++Index)
+		{
+			SectionsToEmit.Add(Index);
+		}
+	}
+
+	// Size gate. Count what would actually be emitted, not the whole LOD, so
+	// asking for one section of a scanned asset still answers.
+	int64 EmittedVertices = 0;
+	for (int32 SectionIndex : SectionsToEmit)
+	{
+		const FGeometrySectionInfo& Section = Snapshot.Sections[SectionIndex];
+		EmittedVertices += static_cast<int64>(Section.MaxVertexIndex) - static_cast<int64>(Section.MinVertexIndex) + 1;
+	}
+	if (!bDumpToFile && EmittedVertices > GeometryInlineVertexCap)
+	{
+		return MCPError(FString::Printf(
+			TEXT("This request would return %lld vertices, over the %d inline limit. Pass dumpToFile=true to write the full data to a file, or narrow it with sectionIndex / a higher lodIndex."),
+			EmittedVertices, GeometryInlineVertexCap));
+	}
+
+	TArray<TSharedPtr<FJsonValue>> SectionObjects;
+	int64 TotalEmittedTriangles = 0;
+	for (int32 SectionIndex : SectionsToEmit)
+	{
+		const FGeometrySectionInfo& Section = Snapshot.Sections[SectionIndex];
+
+		TSharedPtr<FJsonObject> SectionObj = MakeShared<FJsonObject>();
+		SectionObj->SetNumberField(TEXT("sectionIndex"), Section.SectionIndex);
+		SectionObj->SetNumberField(TEXT("materialIndex"), Section.MaterialIndex);
+		if (!Section.MaterialSlotName.IsEmpty()) SectionObj->SetStringField(TEXT("materialSlotName"), Section.MaterialSlotName);
+		if (!Section.MaterialPath.IsEmpty()) SectionObj->SetStringField(TEXT("materialPath"), Section.MaterialPath);
+		SectionObj->SetNumberField(TEXT("firstIndex"), Section.FirstIndex);
+		SectionObj->SetNumberField(TEXT("triangleCount"), Section.NumTriangles);
+		SectionObj->SetNumberField(TEXT("baseVertexIndex"), Section.MinVertexIndex);
+		SectionObj->SetNumberField(TEXT("maxVertexIndex"), Section.MaxVertexIndex);
+		if (Section.bDisabled) SectionObj->SetBoolField(TEXT("disabled"), true);
+
+		const int32 SectionFirstVertex = static_cast<int32>(Section.MinVertexIndex);
+		const int32 SectionLastVertex = static_cast<int32>(Section.MaxVertexIndex);
+		const int32 SectionVertexCount = SectionLastVertex - SectionFirstVertex + 1;
+		SectionObj->SetNumberField(TEXT("vertexCount"), SectionVertexCount);
+
+		if (bWantPositions)
+		{
+			TArray<TSharedPtr<FJsonValue>> Positions;
+			Positions.Reserve(SectionVertexCount);
+			for (int32 VertexIndex = SectionFirstVertex; VertexIndex <= SectionLastVertex; ++VertexIndex)
+			{
+				if (!Snapshot.Positions.IsValidIndex(VertexIndex)) break;
+				Positions.Add(MakeShared<FJsonValueObject>(GeometryVec3ToJson(Snapshot.Positions[VertexIndex])));
+			}
+			SectionObj->SetArrayField(TEXT("positions"), Positions);
+		}
+
+		if (bWantNormals)
+		{
+			TArray<TSharedPtr<FJsonValue>> Normals;
+			Normals.Reserve(SectionVertexCount);
+			for (int32 VertexIndex = SectionFirstVertex; VertexIndex <= SectionLastVertex; ++VertexIndex)
+			{
+				if (!Snapshot.Normals.IsValidIndex(VertexIndex)) break;
+				Normals.Add(MakeShared<FJsonValueObject>(GeometryVec3ToJson(Snapshot.Normals[VertexIndex])));
+			}
+			SectionObj->SetArrayField(TEXT("normals"), Normals);
+		}
+
+		if (bWantUVs)
+		{
+			TArray<TSharedPtr<FJsonValue>> UVs;
+			UVs.Reserve(SectionVertexCount);
+			for (int32 VertexIndex = SectionFirstVertex; VertexIndex <= SectionLastVertex; ++VertexIndex)
+			{
+				if (!Snapshot.UVs.IsValidIndex(VertexIndex)) break;
+				UVs.Add(MakeShared<FJsonValueObject>(GeometryUVToJson(Snapshot.UVs[VertexIndex])));
+			}
+			SectionObj->SetArrayField(TEXT("uvs"), UVs);
+		}
+
+		if (bWantTriangles)
+		{
+			int32 FirstIndex = 0;
+			int32 IndexCount = 0;
+			TArray<TSharedPtr<FJsonValue>> Triangles;
+			if (GeometrySectionTriangleRange(Snapshot, Section, FirstIndex, IndexCount))
+			{
+				Triangles.Reserve(IndexCount);
+				for (int32 Offset = 0; Offset < IndexCount; ++Offset)
+				{
+					// Section-local, so it indexes this section's own positions
+					// array directly. baseVertexIndex maps it back to LOD-global.
+					const int64 Local = static_cast<int64>(Snapshot.Indices[FirstIndex + Offset]) - SectionFirstVertex;
+					Triangles.Add(MakeShared<FJsonValueNumber>(static_cast<double>(Local)));
+				}
+			}
+			SectionObj->SetArrayField(TEXT("triangles"), Triangles);
+			SectionObj->SetBoolField(TEXT("trianglesAreSectionLocal"), true);
+		}
+
+		TotalEmittedTriangles += Section.NumTriangles;
+		SectionObjects.Add(MakeShared<FJsonValueObject>(SectionObj));
+	}
+
+	auto BuildResult = [&]() -> TSharedPtr<FJsonObject>
+	{
+		auto Result = MCPSuccess();
+		Result->SetStringField(TEXT("assetPath"), AssetPath);
+		Result->SetStringField(TEXT("assetType"), Snapshot.AssetType);
+		Result->SetNumberField(TEXT("lodIndex"), LodIndex);
+		Result->SetNumberField(TEXT("lodCount"), Snapshot.LodCount);
+		Result->SetNumberField(TEXT("uvChannel"), UVChannel);
+		Result->SetNumberField(TEXT("uvChannelCount"), Snapshot.NumTexCoords);
+		Result->SetNumberField(TEXT("vertexCount"), Snapshot.Positions.Num());
+		Result->SetNumberField(TEXT("triangleCount"), Snapshot.Indices.Num() / 3);
+		Result->SetNumberField(TEXT("sectionCount"), Snapshot.Sections.Num());
+		Result->SetNumberField(TEXT("emittedVertexCount"), static_cast<double>(EmittedVertices));
+		Result->SetNumberField(TEXT("emittedTriangleCount"), static_cast<double>(TotalEmittedTriangles));
+		Result->SetArrayField(TEXT("sections"), SectionObjects);
+		return Result;
+	};
+
+	if (bDumpToFile)
+	{
+		const TSharedPtr<FJsonObject> DumpResult = BuildResult();
+		FString ResolvedDumpPath;
+		FString DumpError;
+		if (!WriteGeometryJsonToFile(DumpResult, OutputPath, AssetPath, LodIndex, ResolvedDumpPath, DumpError))
+		{
+			return MCPError(DumpError);
+		}
+
+		auto Result = MCPSuccess();
+		Result->SetStringField(TEXT("assetPath"), AssetPath);
+		Result->SetStringField(TEXT("assetType"), Snapshot.AssetType);
+		Result->SetNumberField(TEXT("lodIndex"), LodIndex);
+		Result->SetNumberField(TEXT("lodCount"), Snapshot.LodCount);
+		Result->SetBoolField(TEXT("dumpedToFile"), true);
+		Result->SetStringField(TEXT("outputPath"), ResolvedDumpPath);
+		Result->SetNumberField(TEXT("vertexCount"), Snapshot.Positions.Num());
+		Result->SetNumberField(TEXT("triangleCount"), Snapshot.Indices.Num() / 3);
+		Result->SetNumberField(TEXT("sectionCount"), Snapshot.Sections.Num());
+		Result->SetNumberField(TEXT("emittedVertexCount"), static_cast<double>(EmittedVertices));
+		Result->SetNumberField(TEXT("emittedTriangleCount"), static_cast<double>(TotalEmittedTriangles));
+		return MCPResult(Result);
+	}
+
+	return MCPResult(BuildResult());
+}
+
+
+TSharedPtr<FJsonValue> FAssetGeometryHandlers::MeasureMeshGeometry(const TSharedPtr<FJsonObject>& Params)
+{
+	FString AssetPath;
+	if (auto Err = RequireStringAlt(Params, TEXT("assetPath"), TEXT("path"), AssetPath)) return Err;
+
+	const int32 LodIndex = OptionalInt(Params, TEXT("lodIndex"), 0);
+	const bool bHasSectionIndex = Params->HasField(TEXT("sectionIndex"));
+	const int32 RequestedSection = OptionalInt(Params, TEXT("sectionIndex"), 0);
+
+	FGeometrySnapshot Snapshot;
+	if (auto Err = BuildGeometrySnapshot(AssetPath, LodIndex, /*UVChannel=*/0, /*bWantNormals=*/false, /*bWantUVs=*/false, Snapshot))
+	{
+		return Err;
+	}
+
+	TArray<int32> SectionsToMeasure;
+	if (bHasSectionIndex)
+	{
+		if (!Snapshot.Sections.IsValidIndex(RequestedSection))
+		{
+			return MCPError(FString::Printf(
+				TEXT("sectionIndex %d out of range (LOD %d has %d sections)"),
+				RequestedSection, LodIndex, Snapshot.Sections.Num()));
+		}
+		SectionsToMeasure.Add(RequestedSection);
+	}
+	else
+	{
+		for (int32 Index = 0; Index < Snapshot.Sections.Num(); ++Index)
+		{
+			SectionsToMeasure.Add(Index);
+		}
+	}
+
+	// Gather the triangles under measurement once, then every metric reads the
+	// same set. Sections can overlap vertex ranges, so triangles, not vertices,
+	// are the unit.
+	TArray<int32> TriangleStarts;
+	for (int32 SectionIndex : SectionsToMeasure)
+	{
+		int32 FirstIndex = 0;
+		int32 IndexCount = 0;
+		if (!GeometrySectionTriangleRange(Snapshot, Snapshot.Sections[SectionIndex], FirstIndex, IndexCount))
+		{
+			continue;
+		}
+		for (int32 Offset = 0; Offset + 2 < IndexCount; Offset += 3)
+		{
+			TriangleStarts.Add(FirstIndex + Offset);
+		}
+	}
+
+	// #938: get_mesh_volume_area() in the engine returns (SurfaceArea, Volume) in
+	// that order, which is the reverse of what its name says, and the two are
+	// plausible numbers for each other so a swap is invisible. Both come back
+	// here as named fields for exactly that reason: there is no positional pair
+	// to get the wrong way round.
+	double SurfaceArea = 0.0;
+	double SignedVolume = 0.0;
+	FBox LocalBox(ForceInit);
+	TSet<int32> TouchedVertices;
+
+	for (int32 TriangleStart : TriangleStarts)
+	{
+		const uint32 I0 = Snapshot.Indices[TriangleStart];
+		const uint32 I1 = Snapshot.Indices[TriangleStart + 1];
+		const uint32 I2 = Snapshot.Indices[TriangleStart + 2];
+		if (!Snapshot.Positions.IsValidIndex(static_cast<int32>(I0)) ||
+			!Snapshot.Positions.IsValidIndex(static_cast<int32>(I1)) ||
+			!Snapshot.Positions.IsValidIndex(static_cast<int32>(I2)))
+		{
+			continue;
+		}
+
+		const FVector V0(Snapshot.Positions[static_cast<int32>(I0)]);
+		const FVector V1(Snapshot.Positions[static_cast<int32>(I1)]);
+		const FVector V2(Snapshot.Positions[static_cast<int32>(I2)]);
+
+		SurfaceArea += 0.5 * FVector::CrossProduct(V1 - V0, V2 - V0).Size();
+		// Signed tetrahedron volume against the origin. Summed over a closed
+		// surface this is the enclosed volume; over an open one it is meaningless,
+		// which is why isClosed is reported next to it.
+		SignedVolume += FVector::DotProduct(V0, FVector::CrossProduct(V1, V2)) / 6.0;
+
+		LocalBox += V0;
+		LocalBox += V1;
+		LocalBox += V2;
+		TouchedVertices.Add(static_cast<int32>(I0));
+		TouchedVertices.Add(static_cast<int32>(I1));
+		TouchedVertices.Add(static_cast<int32>(I2));
+	}
+
+	// Topology: weld by quantised position first, so a UV seam does not read as
+	// an open boundary, then count how many triangles share each undirected edge.
+	bool bTopologyAnalyzed = false;
+	bool bIsClosed = false;
+	bool bIsManifold = false;
+	int32 BoundaryEdgeCount = 0;
+	int32 NonManifoldEdgeCount = 0;
+	FString TopologySkippedReason;
+
+	if (TriangleStarts.Num() > GeometryTopologyTriangleCap)
+	{
+		TopologySkippedReason = FString::Printf(
+			TEXT("%d triangles is over the %d triangle limit for edge-adjacency analysis"),
+			TriangleStarts.Num(), GeometryTopologyTriangleCap);
+	}
+	else if (TriangleStarts.Num() > 0)
+	{
+		TMap<FGeometryWeldKey, int32> WeldedIds;
+		WeldedIds.Reserve(Snapshot.Positions.Num());
+		TArray<int32> VertexToWelded;
+		VertexToWelded.Init(INDEX_NONE, Snapshot.Positions.Num());
+		int32 NextWeldedId = 0;
+		for (int32 VertexIndex = 0; VertexIndex < Snapshot.Positions.Num(); ++VertexIndex)
+		{
+			const FGeometryWeldKey Key = MakeGeometryWeldKey(Snapshot.Positions[VertexIndex]);
+			if (const int32* Existing = WeldedIds.Find(Key))
+			{
+				VertexToWelded[VertexIndex] = *Existing;
+			}
+			else
+			{
+				WeldedIds.Add(Key, NextWeldedId);
+				VertexToWelded[VertexIndex] = NextWeldedId;
+				++NextWeldedId;
+			}
+		}
+
+		TMap<uint64, int32> EdgeUseCount;
+		EdgeUseCount.Reserve(TriangleStarts.Num() * 3);
+		auto AddEdge = [&EdgeUseCount](int32 A, int32 B)
+		{
+			const uint32 Low = static_cast<uint32>(FMath::Min(A, B));
+			const uint32 High = static_cast<uint32>(FMath::Max(A, B));
+			const uint64 Key = (static_cast<uint64>(Low) << 32) | static_cast<uint64>(High);
+			EdgeUseCount.FindOrAdd(Key)++;
+		};
+
+		for (int32 TriangleStart : TriangleStarts)
+		{
+			const int32 I0 = static_cast<int32>(Snapshot.Indices[TriangleStart]);
+			const int32 I1 = static_cast<int32>(Snapshot.Indices[TriangleStart + 1]);
+			const int32 I2 = static_cast<int32>(Snapshot.Indices[TriangleStart + 2]);
+			if (!VertexToWelded.IsValidIndex(I0) || !VertexToWelded.IsValidIndex(I1) || !VertexToWelded.IsValidIndex(I2))
+			{
+				continue;
+			}
+			const int32 W0 = VertexToWelded[I0];
+			const int32 W1 = VertexToWelded[I1];
+			const int32 W2 = VertexToWelded[I2];
+			// A degenerate triangle contributes no real edges.
+			if (W0 == W1 || W1 == W2 || W0 == W2) continue;
+			AddEdge(W0, W1);
+			AddEdge(W1, W2);
+			AddEdge(W2, W0);
+		}
+
+		for (const TPair<uint64, int32>& Edge : EdgeUseCount)
+		{
+			if (Edge.Value == 1) ++BoundaryEdgeCount;
+			else if (Edge.Value > 2) ++NonManifoldEdgeCount;
+		}
+
+		bTopologyAnalyzed = true;
+		bIsManifold = NonManifoldEdgeCount == 0;
+		bIsClosed = bIsManifold && BoundaryEdgeCount == 0;
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("assetPath"), AssetPath);
+	Result->SetStringField(TEXT("assetType"), Snapshot.AssetType);
+	Result->SetNumberField(TEXT("lodIndex"), LodIndex);
+	Result->SetNumberField(TEXT("lodCount"), Snapshot.LodCount);
+	Result->SetNumberField(TEXT("sectionCount"), Snapshot.Sections.Num());
+	if (bHasSectionIndex) Result->SetNumberField(TEXT("sectionIndex"), RequestedSection);
+
+	Result->SetNumberField(TEXT("triangleCount"), TriangleStarts.Num());
+	Result->SetNumberField(TEXT("vertexCount"), TouchedVertices.Num());
+	Result->SetNumberField(TEXT("lodVertexCount"), Snapshot.Positions.Num());
+	Result->SetNumberField(TEXT("lodTriangleCount"), Snapshot.Indices.Num() / 3);
+
+	Result->SetNumberField(TEXT("surfaceArea"), SurfaceArea);
+	Result->SetNumberField(TEXT("volume"), FMath::Abs(SignedVolume));
+	Result->SetNumberField(TEXT("signedVolume"), SignedVolume);
+	Result->SetBoolField(TEXT("volumeIsMeaningful"), bTopologyAnalyzed && bIsClosed);
+	Result->SetStringField(TEXT("units"), TEXT("surfaceArea in cm2, volume in cm3, lengths in cm (Unreal units)"));
+
+	TSharedPtr<FJsonObject> BoundsObj = MakeShared<FJsonObject>();
+	const FVector BoxMin = LocalBox.IsValid ? LocalBox.Min : FVector::ZeroVector;
+	const FVector BoxMax = LocalBox.IsValid ? LocalBox.Max : FVector::ZeroVector;
+	BoundsObj->SetObjectField(TEXT("min"), MCPVec3ToJsonObject(BoxMin));
+	BoundsObj->SetObjectField(TEXT("max"), MCPVec3ToJsonObject(BoxMax));
+	BoundsObj->SetObjectField(TEXT("center"), MCPVec3ToJsonObject((BoxMin + BoxMax) * 0.5));
+	BoundsObj->SetObjectField(TEXT("extent"), MCPVec3ToJsonObject((BoxMax - BoxMin) * 0.5));
+	Result->SetObjectField(TEXT("bounds"), BoundsObj);
+	Result->SetObjectField(TEXT("dimensions"), MCPVec3ToJsonObject(BoxMax - BoxMin));
+
+	// The asset's own cached bounds, which include every LOD and any extension
+	// the artist set, kept separate from the measured box above so the two are
+	// never confused for one another.
+	TSharedPtr<FJsonObject> AssetBoundsObj = MakeShared<FJsonObject>();
+	AssetBoundsObj->SetObjectField(TEXT("origin"), MCPVec3ToJsonObject(Snapshot.Bounds.Origin));
+	AssetBoundsObj->SetObjectField(TEXT("boxExtent"), MCPVec3ToJsonObject(Snapshot.Bounds.BoxExtent));
+	AssetBoundsObj->SetNumberField(TEXT("sphereRadius"), Snapshot.Bounds.SphereRadius);
+	Result->SetObjectField(TEXT("assetBounds"), AssetBoundsObj);
+
+	Result->SetBoolField(TEXT("topologyAnalyzed"), bTopologyAnalyzed);
+	if (bTopologyAnalyzed)
+	{
+		Result->SetBoolField(TEXT("isClosed"), bIsClosed);
+		Result->SetBoolField(TEXT("isManifold"), bIsManifold);
+		Result->SetNumberField(TEXT("boundaryEdgeCount"), BoundaryEdgeCount);
+		Result->SetNumberField(TEXT("nonManifoldEdgeCount"), NonManifoldEdgeCount);
+		Result->SetNumberField(TEXT("weldToleranceCm"), GeometryWeldTolerance);
+	}
+	else if (!TopologySkippedReason.IsEmpty())
+	{
+		Result->SetStringField(TEXT("topologySkippedReason"), TopologySkippedReason);
+	}
+
+	return MCPResult(Result);
+}