ue-mcp 1.2.3 → 1.3.0

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

@@ -7,26 +7,393 @@
 #include "Engine/World.h"
 #include "EngineUtils.h"
 #include "Landscape.h"
+#include "LandscapeDataAccess.h"
+// #939: FLandscapeEditDataInterface, the same height/weight accessor
+// landscape(sculpt) and landscape(paint_layer) write through, so a sample reads
+// back exactly what a paint wrote.
+#include "LandscapeEdit.h"
 #include "LandscapeEditTypes.h"
 #include "LandscapeProxy.h"
 #include "LandscapeStreamingProxy.h"
 #include "LandscapeInfo.h"
 #include "LandscapeComponent.h"
+#include "LandscapeHeightfieldCollisionComponent.h"
 #include "LandscapeSplineActor.h"
 #include "LandscapeSplinesComponent.h"
 #include "LandscapeSplineControlPoint.h"
 #include "LandscapeSplineSegment.h"
+#include "CollisionQueryParams.h"
+#include "Engine/HitResult.h"
+#include "PhysicalMaterials/PhysicalMaterial.h"
 #include "Kismet/KismetSystemLibrary.h"
 #include "Misc/FileHelper.h"
+#include "Misc/SecureHash.h"
+#include "HAL/IConsoleManager.h"
+#include "HAL/PlatformProcess.h"
+#include "HAL/PlatformTime.h"
 #include "Materials/MaterialInterface.h"
 #include "EditorScriptingUtilities/Public/EditorAssetLibrary.h"
+#include "RenderingThread.h"
 #include "Components/PrimitiveComponent.h"
+#include "PhysicsEngine/BodyInstance.h"
 #include "LandscapeLayerInfoObject.h"
 #include "UObject/Package.h"
+#include "UObject/UnrealType.h"
 #include "AssetRegistry/AssetRegistryModule.h"
 #include "AssetToolsModule.h"
 #include "IAssetTools.h"
 
+#if WITH_DEV_AUTOMATION_TESTS
+#include "Misc/AutomationTest.h"
+#endif
+
+#if UE_MCP_HAS_5_8_API
+
+namespace
+{
+	constexpr float HeightCollisionToleranceCm = 0.25f;
+
+	struct FLandscapeHeightCollisionSignature
+	{
+		ULandscapeHeightfieldCollisionComponent* Collision = nullptr;
+		FString ComponentPath;
+		int64 RawElementCount = 0;
+		int32 ComplexSampleCount = 0;
+		int32 CollisionSizeVerts = 0;
+		int32 SimpleSampleCount = 0;
+		int32 SimpleCollisionSizeVerts = 0;
+		FSHAHash RawHash;
+		FSHAHash LiveHash;
+		FTransform ComponentTransform;
+		float RawMinWorldZ = 0.0f;
+		float RawMaxWorldZ = 0.0f;
+		float LiveMinWorldZ = 0.0f;
+		float LiveMaxWorldZ = 0.0f;
+	};
+
+	bool ReadCollisionSampleInfo(
+		const ULandscapeHeightfieldCollisionComponent* Collision,
+		ULandscapeHeightfieldCollisionComponent::FCollisionSampleInfo& OutInfo,
+		FString& OutError)
+	{
+		// GetCollisionSampleInfo is public but not LANDSCAPE_API, so calling it
+		// from an external plugin compiles and then fails to link. Reproduce its
+		// four-line calculation from the reflected size properties instead.
+		static const FIntProperty* CollisionSizeQuadsProperty =
+			FindFProperty<FIntProperty>(
+				ULandscapeHeightfieldCollisionComponent::StaticClass(),
+				TEXT("CollisionSizeQuads"));
+		static const FIntProperty* SimpleCollisionSizeQuadsProperty =
+			FindFProperty<FIntProperty>(
+				ULandscapeHeightfieldCollisionComponent::StaticClass(),
+				TEXT("SimpleCollisionSizeQuads"));
+		if (!CollisionSizeQuadsProperty || !SimpleCollisionSizeQuadsProperty)
+		{
+			OutError = TEXT("Landscape collision size properties are unavailable");
+			return false;
+		}
+
+		const int32 CollisionSizeQuads =
+			CollisionSizeQuadsProperty->GetPropertyValue_InContainer(Collision);
+		const int32 SimpleCollisionSizeQuads =
+			SimpleCollisionSizeQuadsProperty->GetPropertyValue_InContainer(Collision);
+		if (CollisionSizeQuads <= 0 || SimpleCollisionSizeQuads < 0)
+		{
+			OutError = FString::Printf(
+				TEXT("Invalid landscape collision quad dimensions: complex=%d, simple=%d"),
+				CollisionSizeQuads, SimpleCollisionSizeQuads);
+			return false;
+		}
+
+		OutInfo.CollisionSizeVerts = CollisionSizeQuads + 1;
+		OutInfo.SimpleCollisionSizeVerts =
+			SimpleCollisionSizeQuads > 0 ? SimpleCollisionSizeQuads + 1 : 0;
+		OutInfo.NumSamples = FMath::Square(OutInfo.CollisionSizeVerts);
+		OutInfo.NumSimpleSamples = FMath::Square(OutInfo.SimpleCollisionSizeVerts);
+		return true;
+	}
+
+	bool BuildHeightCollisionSignature(
+		TConstArrayView<uint16> RawHeights,
+		int32 ComplexSampleCount,
+		int32 CollisionSizeVerts,
+		int32 SimpleSampleCount,
+		int32 SimpleCollisionSizeVerts,
+		TConstArrayView<float> LiveWorldHeights,
+		const FTransform& ComponentTransform,
+		FLandscapeHeightCollisionSignature& OutSignature,
+		FString& OutError)
+	{
+		if (ComplexSampleCount <= 0 || CollisionSizeVerts <= 1 ||
+			ComplexSampleCount != CollisionSizeVerts * CollisionSizeVerts)
+		{
+			OutError = TEXT("Invalid landscape collision sample dimensions");
+			return false;
+		}
+		if (SimpleSampleCount < 0 || SimpleCollisionSizeVerts < 0 ||
+			(SimpleSampleCount == 0) != (SimpleCollisionSizeVerts == 0) ||
+			(SimpleSampleCount > 0 && SimpleSampleCount != SimpleCollisionSizeVerts * SimpleCollisionSizeVerts))
+		{
+			OutError = TEXT("Invalid simple landscape collision sample dimensions");
+			return false;
+		}
+		const int32 TotalSampleCount = ComplexSampleCount + SimpleSampleCount;
+		if (RawHeights.Num() != TotalSampleCount)
+		{
+			OutError = FString::Printf(
+				TEXT("Raw collision height data has %d element(s), expected %d complex + simple samples"),
+				RawHeights.Num(), TotalSampleCount);
+			return false;
+		}
+		if (LiveWorldHeights.Num() != TotalSampleCount)
+		{
+			OutError = FString::Printf(
+				TEXT("Live collision heightfields returned %d sample(s), expected %d"),
+				LiveWorldHeights.Num(), TotalSampleCount);
+			return false;
+		}
+
+		OutSignature.RawElementCount = RawHeights.Num();
+		OutSignature.ComplexSampleCount = ComplexSampleCount;
+		OutSignature.CollisionSizeVerts = CollisionSizeVerts;
+		OutSignature.SimpleSampleCount = SimpleSampleCount;
+		OutSignature.SimpleCollisionSizeVerts = SimpleCollisionSizeVerts;
+		OutSignature.ComponentTransform = ComponentTransform;
+		OutSignature.RawHash = FSHA1::HashBuffer(
+			RawHeights.GetData(), static_cast<uint64>(RawHeights.Num()) * sizeof(uint16));
+
+		FSHA1 LiveHasher;
+		OutSignature.RawMinWorldZ = TNumericLimits<float>::Max();
+		OutSignature.RawMaxWorldZ = TNumericLimits<float>::Lowest();
+		OutSignature.LiveMinWorldZ = TNumericLimits<float>::Max();
+		OutSignature.LiveMaxWorldZ = TNumericLimits<float>::Lowest();
+		for (int32 Index = 0; Index < TotalSampleCount; ++Index)
+		{
+			const float ExpectedWorldZ = static_cast<float>(ComponentTransform.TransformPosition(
+				FVector(0.0, 0.0, LandscapeDataAccess::GetLocalHeight(RawHeights[Index]))).Z);
+			const float LiveWorldZ = LiveWorldHeights[Index];
+			if (!FMath::IsFinite(ExpectedWorldZ) || !FMath::IsFinite(LiveWorldZ) ||
+				!FMath::IsNearlyEqual(ExpectedWorldZ, LiveWorldZ, HeightCollisionToleranceCm))
+			{
+				OutError = FString::Printf(
+					TEXT("Raw/live collision height mismatch at sample %d: raw predicts %.3f cm, live heightfield reports %.3f cm"),
+					Index, ExpectedWorldZ, LiveWorldZ);
+				return false;
+			}
+
+			OutSignature.RawMinWorldZ = FMath::Min(OutSignature.RawMinWorldZ, ExpectedWorldZ);
+			OutSignature.RawMaxWorldZ = FMath::Max(OutSignature.RawMaxWorldZ, ExpectedWorldZ);
+			OutSignature.LiveMinWorldZ = FMath::Min(OutSignature.LiveMinWorldZ, LiveWorldZ);
+			OutSignature.LiveMaxWorldZ = FMath::Max(OutSignature.LiveMaxWorldZ, LiveWorldZ);
+
+			// Hash at 0.1 cm precision. A recreated Chaos heightfield can differ by a
+			// tiny floating-point amount while still representing the same uint16
+			// source height, but a flattened or shifted field must never compare equal.
+			const int64 QuantizedHeight = FMath::RoundToInt64(static_cast<double>(LiveWorldZ) * 10.0);
+			LiveHasher.Update(QuantizedHeight);
+		}
+		OutSignature.LiveHash = LiveHasher.Finalize();
+		return true;
+	}
+
+	bool CaptureHeightCollisionSignature(
+		ULandscapeHeightfieldCollisionComponent* Collision,
+		FLandscapeHeightCollisionSignature& OutSignature,
+		FString& OutError)
+	{
+		if (!Collision)
+		{
+			OutError = TEXT("Landscape collision component is null");
+			return false;
+		}
+		const FBodyInstance* BodyInstance = Collision->GetBodyInstance();
+		if (!Collision->IsRegistered() || !Collision->IsPhysicsStateCreated() ||
+			!BodyInstance || !BodyInstance->IsValidBodyInstance())
+		{
+			OutError = FString::Printf(
+				TEXT("%s does not have a registered, valid physics body"), *Collision->GetPathName());
+			return false;
+		}
+
+		ULandscapeHeightfieldCollisionComponent::FCollisionSampleInfo SampleInfo;
+		if (!ReadCollisionSampleInfo(Collision, SampleInfo, OutError))
+		{
+			return false;
+		}
+		const int64 ExpectedRawElements = static_cast<int64>(SampleInfo.NumSamples) + SampleInfo.NumSimpleSamples;
+		const int64 RawElementCount = Collision->CollisionHeightData.GetElementCount();
+		if (ExpectedRawElements <= 0 || RawElementCount != ExpectedRawElements)
+		{
+			OutError = FString::Printf(
+				TEXT("%s has %lld raw collision height element(s), expected %lld"),
+				*Collision->GetPathName(), RawElementCount, ExpectedRawElements);
+			return false;
+		}
+
+		TArray<float> LiveWorldHeights;
+		LiveWorldHeights.SetNumUninitialized(static_cast<int32>(ExpectedRawElements));
+		if (!Collision->FillHeightTile(
+			MakeArrayView(LiveWorldHeights.GetData(), SampleInfo.NumSamples),
+			0,
+			SampleInfo.CollisionSizeVerts))
+		{
+			OutError = FString::Printf(
+				TEXT("%s has no readable live complex collision heightfield"), *Collision->GetPathName());
+			return false;
+		}
+		if (SampleInfo.NumSimpleSamples > 0)
+		{
+			const FTransform& WorldTransform = Collision->GetComponentTransform();
+			for (int32 Y = 0; Y < SampleInfo.SimpleCollisionSizeVerts; ++Y)
+			{
+				for (int32 X = 0; X < SampleInfo.SimpleCollisionSizeVerts; ++X)
+				{
+					const TOptional<float> SimpleLocalHeight =
+						Collision->GetHeight(X, Y, EHeightfieldSource::Simple);
+					if (!SimpleLocalHeight.IsSet())
+					{
+						OutError = FString::Printf(
+							TEXT("%s has no readable live simple collision heightfield"),
+							*Collision->GetPathName());
+						return false;
+					}
+					const int32 SampleIndex = SampleInfo.NumSamples +
+						Y * SampleInfo.SimpleCollisionSizeVerts + X;
+					LiveWorldHeights[SampleIndex] = static_cast<float>(
+						WorldTransform.TransformPositionNoScale(
+							FVector(0.0, 0.0, SimpleLocalHeight.GetValue())).Z);
+				}
+			}
+		}
+
+		const uint16* RawHeightData = static_cast<const uint16*>(Collision->CollisionHeightData.LockReadOnly());
+		if (!RawHeightData)
+		{
+			Collision->CollisionHeightData.Unlock();
+			OutError = FString::Printf(
+				TEXT("%s raw collision height data could not be locked"), *Collision->GetPathName());
+			return false;
+		}
+
+		OutSignature.Collision = Collision;
+		OutSignature.ComponentPath = Collision->GetPathName();
+		const bool bBuilt = BuildHeightCollisionSignature(
+			MakeArrayView(RawHeightData, static_cast<int32>(RawElementCount)),
+			SampleInfo.NumSamples,
+			SampleInfo.CollisionSizeVerts,
+			SampleInfo.NumSimpleSamples,
+			SampleInfo.SimpleCollisionSizeVerts,
+			LiveWorldHeights,
+			Collision->GetComponentTransform(),
+			OutSignature,
+			OutError);
+		Collision->CollisionHeightData.Unlock();
+		return bBuilt;
+	}
+
+	bool MatchesHeightCollisionSignature(
+		const FLandscapeHeightCollisionSignature& Baseline,
+		const FLandscapeHeightCollisionSignature& Current,
+		FString& OutError)
+	{
+		if (Baseline.RawElementCount != Current.RawElementCount || Baseline.RawHash != Current.RawHash)
+		{
+			OutError = FString::Printf(
+				TEXT("%s raw collision height data changed"), *Baseline.ComponentPath);
+			return false;
+		}
+		if (Baseline.ComplexSampleCount != Current.ComplexSampleCount ||
+			Baseline.CollisionSizeVerts != Current.CollisionSizeVerts ||
+			Baseline.SimpleSampleCount != Current.SimpleSampleCount ||
+			Baseline.SimpleCollisionSizeVerts != Current.SimpleCollisionSizeVerts ||
+			!Baseline.ComponentTransform.Equals(Current.ComponentTransform, 1.e-6f))
+		{
+			OutError = FString::Printf(
+				TEXT("%s collision dimensions or transform changed"), *Baseline.ComponentPath);
+			return false;
+		}
+		if (Baseline.LiveHash != Current.LiveHash ||
+			!FMath::IsNearlyEqual(Baseline.LiveMinWorldZ, Current.LiveMinWorldZ, HeightCollisionToleranceCm) ||
+			!FMath::IsNearlyEqual(Baseline.LiveMaxWorldZ, Current.LiveMaxWorldZ, HeightCollisionToleranceCm))
+		{
+			OutError = FString::Printf(
+				TEXT("%s live collision heightfield changed (baseline %.3f..%.3f cm, current %.3f..%.3f cm)"),
+				*Baseline.ComponentPath,
+				Baseline.LiveMinWorldZ, Baseline.LiveMaxWorldZ,
+				Current.LiveMinWorldZ, Current.LiveMaxWorldZ);
+			return false;
+		}
+		return true;
+	}
+
+	bool ValidateLandscapeCollisionPreflight(
+		int32 LandscapeComponents,
+		int32 CollisionComponents,
+		int32 CapturedHeightComponents,
+		int32 PendingLayerUpdateComponents,
+		bool bLandscapeLayersUpToDate,
+		bool bTextureResourcesReady,
+		FString& OutError)
+	{
+		if (CollisionComponents == 0)
+		{
+			OutError = TEXT("No registered landscape collision components were available to refresh");
+			return false;
+		}
+		if (CollisionComponents != LandscapeComponents ||
+			CapturedHeightComponents != CollisionComponents)
+		{
+			OutError = FString::Printf(
+				TEXT("Loaded proxy coverage is incomplete: %d of %d landscape component(s) have registered, captured collision"),
+				CapturedHeightComponents, LandscapeComponents);
+			return false;
+		}
+		if (!bLandscapeLayersUpToDate || PendingLayerUpdateComponents > 0)
+		{
+			OutError = TEXT("The parent landscape has pending edit-layer updates. A later PreSave could replace collision heights; let the landscape finish updating and validate it before retrying.");
+			return false;
+		}
+		if (!bTextureResourcesReady)
+		{
+			OutError = TEXT("The parent landscape could not make its texture resources resident");
+			return false;
+		}
+		return true;
+	}
+
+	class FScopedLandscapePhysicalMaterialRecreateMode
+	{
+	public:
+		FScopedLandscapePhysicalMaterialRecreateMode()
+		{
+			Variable = IConsoleManager::Get().FindConsoleVariable(
+				TEXT("landscape.ApplyPhysicalMaterialChangesImmediately"));
+			if (Variable)
+			{
+				Variable->Set(0, ECVF_SetByTemp, OverrideTag);
+				bEffective = Variable->GetInt() == 0;
+			}
+		}
+
+		~FScopedLandscapePhysicalMaterialRecreateMode()
+		{
+			if (Variable)
+			{
+				Variable->Unset(ECVF_SetByTemp, OverrideTag);
+			}
+		}
+
+		bool IsValid() const { return Variable != nullptr && bEffective; }
+
+	private:
+		static inline const FName OverrideTag = TEXT("UE_MCP_LandscapePhysicalMaterialCollision");
+		IConsoleVariable* Variable = nullptr;
+		bool bEffective = false;
+	};
+}
+
+#endif // UE_MCP_HAS_5_8_API
+
 void FLandscapeHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 {
 	Registry.RegisterHandler(TEXT("get_landscape_info"), &GetLandscapeInfo);
@@ -42,6 +409,7 @@ void FLandscapeHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	// #733: World Partition landscape streaming-proxy enumeration + spatial lookup.
 	Registry.RegisterHandler(TEXT("list_landscape_proxies"), &ListLandscapeProxies);
 	Registry.RegisterHandler(TEXT("find_landscape_proxy_at"), &FindLandscapeProxyAt);
+	Registry.RegisterHandlerWithTimeout(TEXT("refresh_landscape_physical_material_collision"), &RefreshPhysicalMaterialCollision, 600.0f);
 	Registry.RegisterHandlerWithTimeout(TEXT("sculpt_landscape"), &Sculpt, 120.0f);
 	Registry.RegisterHandlerWithTimeout(TEXT("paint_landscape_layer"), &PaintLayer, 120.0f);
 }
@@ -140,61 +508,295 @@ TSharedPtr<FJsonValue> FLandscapeHandlers::ListLandscapeLayers(const TSharedPtr<
 	return MCPResult(Result);
 }
 
+// landscape(sample): height AND paint-layer weights at a world XY (#939).
+//
+// The action advertised "Params: x, y" and the handler required an object
+// called `point`, so BOTH documented call shapes failed with "Missing 'point'
+// parameter" and there was no working call at all. It also never returned a
+// single layer weight despite advertising "height/layers", which left reading a
+// weight to rendering the weightmap into a render target and reading that back.
+//
+// Both halves are fixed here. The position is accepted in every shape the
+// category already uses (x/y, point{x,y}, worldX/worldY, all named in the
+// schema), and the weights come from the same FLandscapeEditDataInterface that
+// landscape(paint_layer) writes through, so a sample taken after a paint reads
+// back the number that was painted. No edit layer is selected, which is what
+// makes the read the MERGED result the renderer and the physics use, rather
+// than one layer's contribution to it.
 TSharedPtr<FJsonValue> FLandscapeHandlers::SampleLandscape(const TSharedPtr<FJsonObject>& Params)
 {
+	// Position, in every shape the schema names. `point` may carry a z, which is
+	// only ever used as the origin of the confirmation trace: the surface height
+	// is what this action answers, so it is never an input to itself.
+	double WorldX = 0.0;
+	double WorldY = 0.0;
+	double TraceOriginZ = 0.0;
+	bool bHavePosition = false;
+
 	const TSharedPtr<FJsonObject>* PointObj = nullptr;
-	if (!Params->TryGetObjectField(TEXT("point"), PointObj))
+	if (Params->TryGetObjectField(TEXT("point"), PointObj) && PointObj && PointObj->IsValid())
 	{
-		return MCPError(TEXT("Missing 'point' parameter"));
+		(*PointObj)->TryGetNumberField(TEXT("x"), WorldX);
+		(*PointObj)->TryGetNumberField(TEXT("y"), WorldY);
+		(*PointObj)->TryGetNumberField(TEXT("z"), TraceOriginZ);
+		bHavePosition = true;
+	}
+	else if (Params->HasField(TEXT("x")) && Params->HasField(TEXT("y")))
+	{
+		WorldX = OptionalNumber(Params, TEXT("x"), 0.0);
+		WorldY = OptionalNumber(Params, TEXT("y"), 0.0);
+		bHavePosition = true;
+	}
+	else if (Params->HasField(TEXT("worldX")) && Params->HasField(TEXT("worldY")))
+	{
+		// The names landscape(find_proxy_at) takes. A caller moving between the
+		// two actions should not have to rename the same two numbers.
+		WorldX = OptionalNumber(Params, TEXT("worldX"), 0.0);
+		WorldY = OptionalNumber(Params, TEXT("worldY"), 0.0);
+		bHavePosition = true;
+	}
+	if (!bHavePosition)
+	{
+		return MCPError(TEXT("Missing sample position. Pass x and y, or point {x, y}, or worldX and worldY (all world space)."));
 	}
-
-	FVector Point;
-	Point.X = (*PointObj)->GetNumberField(TEXT("x"));
-	Point.Y = (*PointObj)->GetNumberField(TEXT("y"));
-	Point.Z = (*PointObj)->GetNumberField(TEXT("z"));
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	// Find the first landscape and sample height
+	// Which landscape. A label picks one explicitly; without one, every proxy in
+	// the world contributes its ULandscapeInfo and the point decides between
+	// them, because a map with two landscapes has no single right default.
+	// #983: actorPath narrows to exactly one proxy when several share a label,
+	// which is what a World Partition map full of streaming proxies looks like.
+	const FString ActorLabel = OptionalString(Params, TEXT("actorLabel"));
+	const FString ActorPath = OptionalString(Params, TEXT("actorPath"));
+	// Normalised the same way MCPFindActorByPath normalises, so the export-text
+	// form (Actor'/Game/...') resolves here exactly as it does on every other
+	// action rather than silently matching nothing (#983).
+	const FString WantedPath = ActorPath.IsEmpty()
+		? FString()
+		: FPackageName::ExportTextPathToObjectPath(ActorPath).TrimStartAndEnd();
+	TArray<ULandscapeInfo*> Candidates;
 	for (TActorIterator<ALandscapeProxy> It(World); It; ++It)
 	{
-		ALandscapeProxy* Landscape = *It;
-		if (!Landscape) continue;
+		ALandscapeProxy* Proxy = *It;
+		if (!Proxy) continue;
+		if (!WantedPath.IsEmpty() && !Proxy->GetPathName().Equals(WantedPath, ESearchCase::IgnoreCase)) continue;
+		if (!ActorLabel.IsEmpty() && !Proxy->GetActorLabel().Equals(ActorLabel, ESearchCase::IgnoreCase)) continue;
+		ULandscapeInfo* ProxyInfo = Proxy->GetLandscapeInfo();
+		if (!ProxyInfo) continue;
+		if (Candidates.Contains(ProxyInfo)) continue;
+		Candidates.Add(ProxyInfo);
+	}
+	if (Candidates.Num() == 0)
+	{
+		if (ActorLabel.IsEmpty() && ActorPath.IsEmpty())
+		{
+			return MCPError(TEXT("No landscape in the current level. Create one with landscape(create)."));
+		}
+		return MCPError(FString::Printf(
+			TEXT("No landscape actor matched '%s' (nothing with a registered LandscapeInfo matched)"),
+			ActorPath.IsEmpty() ? *ActorLabel : *ActorPath));
+	}
+
+	// Pick the landscape whose quad extent actually covers the point. With one
+	// landscape this is the only candidate and the extent test still reports
+	// whether the point is on it, which is the difference between "weight is
+	// zero here" and "this position is not on the landscape at all".
+	ULandscapeInfo* Info = nullptr;
+	FTransform LandscapeToWorld;
+	FVector LocalPoint = FVector::ZeroVector;
+	FIntRect Extent(0, 0, 0, 0);
+	for (ULandscapeInfo* Candidate : Candidates)
+	{
+		ALandscapeProxy* Reference = Candidate->GetLandscapeProxy();
+		if (!Reference) continue;
+		FIntRect CandidateExtent;
+		if (!Candidate->GetLandscapeExtent(CandidateExtent)) continue;
+
+		const FTransform CandidateTransform = Reference->ActorToWorld();
+		const FVector CandidateLocal =
+			CandidateTransform.InverseTransformPosition(FVector(WorldX, WorldY, 0.0));
+		// RoundToInt32, not RoundToInt: the double overload of the latter
+		// returns int64 and would narrow on the way into these.
+		const int32 QuadX = FMath::RoundToInt32(CandidateLocal.X);
+		const int32 QuadY = FMath::RoundToInt32(CandidateLocal.Y);
+		const bool bCovers =
+			QuadX >= CandidateExtent.Min.X && QuadX <= CandidateExtent.Max.X &&
+			QuadY >= CandidateExtent.Min.Y && QuadY <= CandidateExtent.Max.Y;
+
+		// Remember the first candidate either way, so a point off every
+		// landscape still reports which one it was measured against.
+		if (!Info || bCovers)
+		{
+			Info = Candidate;
+			LandscapeToWorld = CandidateTransform;
+			LocalPoint = CandidateLocal;
+			Extent = CandidateExtent;
+		}
+		if (bCovers) break;
+	}
+	if (!Info)
+	{
+		return MCPError(TEXT("Landscape found but its LandscapeInfo has no registered extent yet (are its components loaded?)"));
+	}
 
-		// Use line trace to get the landscape height at the given point
-		FVector TraceStart(Point.X, Point.Y, Point.Z + 100000.0f);
-		FVector TraceEnd(Point.X, Point.Y, Point.Z - 100000.0f);
+	ALandscapeProxy* ReferenceProxy = Info->GetLandscapeProxy();
+	const int32 QuadX = FMath::RoundToInt32(LocalPoint.X);
+	const int32 QuadY = FMath::RoundToInt32(LocalPoint.Y);
+	const bool bInBounds =
+		QuadX >= Extent.Min.X && QuadX <= Extent.Max.X &&
+		QuadY >= Extent.Min.Y && QuadY <= Extent.Max.Y;
 
-		FHitResult HitResult;
-		FCollisionQueryParams QueryParams;
-		QueryParams.bTraceComplex = true;
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("landscape"), ReferenceProxy ? ReferenceProxy->GetActorLabel() : FString());
+	TSharedPtr<FJsonObject> QuadObj = MakeShared<FJsonObject>();
+	QuadObj->SetNumberField(TEXT("x"), QuadX);
+	QuadObj->SetNumberField(TEXT("y"), QuadY);
+	Result->SetObjectField(TEXT("quad"), QuadObj);
+	Result->SetBoolField(TEXT("inBounds"), bInBounds);
+	TSharedPtr<FJsonObject> ExtentObj = MakeShared<FJsonObject>();
+	ExtentObj->SetNumberField(TEXT("minX"), Extent.Min.X);
+	ExtentObj->SetNumberField(TEXT("minY"), Extent.Min.Y);
+	ExtentObj->SetNumberField(TEXT("maxX"), Extent.Max.X);
+	ExtentObj->SetNumberField(TEXT("maxY"), Extent.Max.Y);
+	Result->SetObjectField(TEXT("quadExtent"), ExtentObj);
+
+	if (!bInBounds)
+	{
+		Result->SetBoolField(TEXT("hit"), false);
+		Result->SetStringField(TEXT("reason"),
+			TEXT("The world position is outside this landscape's loaded quad extent, so height and weights would both read as zero rather than as measurements. On a World Partition map check landscape(find_proxy_at) first."));
+		return MCPResult(Result);
+	}
+
+	// One edit-data interface for the height and every layer, with no edit layer
+	// selected so the read is the merged result rather than one layer's own
+	// contribution to it.
+	FLandscapeEditDataInterface EditData(Info);
 
-		if (World->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, ECC_WorldStatic, QueryParams))
+	uint16 RawHeight = 0;
+	{
+		int32 X1 = QuadX, Y1 = QuadY, X2 = QuadX, Y2 = QuadY;
+		// GetHeightData rewrites the rect with the range it could actually
+		// serve, so an unloaded component comes back as an inverted rect rather
+		// than as a zero sample that reads like real data.
+		EditData.GetHeightData(X1, Y1, X2, Y2, &RawHeight, 0);
+		if (X2 < X1 || Y2 < Y1)
 		{
-			if (HitResult.GetActor() && HitResult.GetActor()->IsA(ALandscapeProxy::StaticClass()))
+			Result->SetBoolField(TEXT("hit"), false);
+			Result->SetStringField(TEXT("reason"),
+				TEXT("No landscape height data at this position (the covering component is not loaded). Pin it with level(load_actor_descs) first."));
+			return MCPResult(Result);
+		}
+	}
+
+	const double LocalHeight = LandscapeDataAccess::GetLocalHeight(RawHeight);
+	const FVector SurfaceWorld = LandscapeToWorld.TransformPosition(
+		FVector(static_cast<double>(QuadX), static_cast<double>(QuadY), static_cast<double>(LocalHeight)));
+
+	Result->SetBoolField(TEXT("hit"), true);
+	Result->SetNumberField(TEXT("height"), SurfaceWorld.Z);
+	Result->SetNumberField(TEXT("rawHeight"), RawHeight);
+	TSharedPtr<FJsonObject> LocationObj = MakeShared<FJsonObject>();
+	LocationObj->SetNumberField(TEXT("x"), SurfaceWorld.X);
+	LocationObj->SetNumberField(TEXT("y"), SurfaceWorld.Y);
+	LocationObj->SetNumberField(TEXT("z"), SurfaceWorld.Z);
+	Result->SetObjectField(TEXT("location"), LocationObj);
+
+	// Paint-layer weights, the half that had no read at all. Each layer is
+	// reported both as the raw 0..255 weightmap byte and as the 0..1 fraction,
+	// because the editor shows one and a material reads the other.
+	if (OptionalBool(Params, TEXT("includeLayers"), true))
+	{
+		const FString LayerFilter = OptionalString(Params, TEXT("layerName"));
+		TArray<TSharedPtr<FJsonValue>> LayerArray;
+		double TotalWeight = 0.0;
+		FString DominantLayer;
+		double DominantWeight = -1.0;
+		TArray<FString> KnownLayers;
+
+		for (const FLandscapeInfoLayerSettings& LayerSettings : Info->Layers)
+		{
+			ULandscapeLayerInfoObject* LayerInfo = LayerSettings.LayerInfoObj;
+			if (!LayerInfo) continue;
+			const FString LayerName = LayerSettings.GetLayerName().ToString();
+			KnownLayers.Add(LayerName);
+			if (!LayerFilter.IsEmpty() && !LayerName.Equals(LayerFilter, ESearchCase::IgnoreCase)) continue;
+
+			uint8 RawWeight = 0;
+			int32 X1 = QuadX, Y1 = QuadY, X2 = QuadX, Y2 = QuadY;
+			EditData.GetWeightData(LayerInfo, X1, Y1, X2, Y2, &RawWeight, 0);
+			if (X2 < X1 || Y2 < Y1) continue;
+
+			const double Weight = static_cast<double>(RawWeight) / 255.0;
+			TotalWeight += Weight;
+			if (Weight > DominantWeight)
+			{
+				DominantWeight = Weight;
+				DominantLayer = LayerName;
+			}
+
+			TSharedPtr<FJsonObject> LayerObj = MakeShared<FJsonObject>();
+			LayerObj->SetStringField(TEXT("name"), LayerName);
+			LayerObj->SetNumberField(TEXT("weight"), Weight);
+			LayerObj->SetNumberField(TEXT("weight255"), RawWeight);
+			LayerObj->SetStringField(TEXT("layerInfo"), LayerInfo->GetPathName());
+			if (UPhysicalMaterial* PhysMat = LayerInfo->GetPhysicalMaterial())
 			{
-				auto Result = MCPSuccess();
-				Result->SetNumberField(TEXT("height"), HitResult.Location.Z);
-				TSharedPtr<FJsonObject> HitPoint = MakeShared<FJsonObject>();
-				HitPoint->SetNumberField(TEXT("x"), HitResult.Location.X);
-				HitPoint->SetNumberField(TEXT("y"), HitResult.Location.Y);
-				HitPoint->SetNumberField(TEXT("z"), HitResult.Location.Z);
-				Result->SetObjectField(TEXT("hitLocation"), HitPoint);
-
-				TSharedPtr<FJsonObject> Normal = MakeShared<FJsonObject>();
-				Normal->SetNumberField(TEXT("x"), HitResult.Normal.X);
-				Normal->SetNumberField(TEXT("y"), HitResult.Normal.Y);
-				Normal->SetNumberField(TEXT("z"), HitResult.Normal.Z);
-				Result->SetObjectField(TEXT("normal"), Normal);
-
-				Result->SetBoolField(TEXT("hit"), true);
-				return MCPResult(Result);
+				LayerObj->SetStringField(TEXT("physicalMaterial"), PhysMat->GetPathName());
 			}
+			LayerArray.Add(MakeShared<FJsonValueObject>(LayerObj));
+		}
+
+		Result->SetArrayField(TEXT("layers"), LayerArray);
+		Result->SetNumberField(TEXT("layerCount"), LayerArray.Num());
+		Result->SetNumberField(TEXT("totalWeight"), TotalWeight);
+		if (!DominantLayer.IsEmpty())
+		{
+			Result->SetStringField(TEXT("dominantLayer"), DominantLayer);
+			Result->SetNumberField(TEXT("dominantWeight"), DominantWeight);
+		}
+		if (!LayerFilter.IsEmpty() && LayerArray.Num() == 0)
+		{
+			Result->SetStringField(TEXT("layerNote"), FString::Printf(
+				TEXT("No layer named '%s' is registered on this landscape. Registered layers: [%s]. Add one with landscape(add_layer_info)."),
+				*LayerFilter, *FString::Join(KnownLayers, TEXT(", "))));
 		}
 	}
 
-	auto Result = MCPSuccess();
-	Result->SetBoolField(TEXT("hit"), false);
+	// A confirmation trace against the collision heightfield, kept because it is
+	// the only source of a surface normal and because a disagreement between it
+	// and the heightmap is itself the answer to "is my collision stale".
+	{
+		const double TraceZ = FMath::Max(TraceOriginZ, SurfaceWorld.Z);
+		const FVector TraceStart(SurfaceWorld.X, SurfaceWorld.Y, TraceZ + 100000.0);
+		const FVector TraceEnd(SurfaceWorld.X, SurfaceWorld.Y, TraceZ - 200000.0);
+		FHitResult HitResult;
+		FCollisionQueryParams QueryParams(SCENE_QUERY_STAT(MCPLandscapeSample), /*bTraceComplex*/ true);
+		const bool bTraceHit =
+			World->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, ECC_WorldStatic, QueryParams) &&
+			HitResult.GetActor() != nullptr &&
+			HitResult.GetActor()->IsA(ALandscapeProxy::StaticClass());
+		Result->SetBoolField(TEXT("traceHit"), bTraceHit);
+		if (bTraceHit)
+		{
+			TSharedPtr<FJsonObject> HitPoint = MakeShared<FJsonObject>();
+			HitPoint->SetNumberField(TEXT("x"), HitResult.Location.X);
+			HitPoint->SetNumberField(TEXT("y"), HitResult.Location.Y);
+			HitPoint->SetNumberField(TEXT("z"), HitResult.Location.Z);
+			Result->SetObjectField(TEXT("hitLocation"), HitPoint);
+			Result->SetNumberField(TEXT("traceHeight"), HitResult.Location.Z);
+
+			TSharedPtr<FJsonObject> Normal = MakeShared<FJsonObject>();
+			Normal->SetNumberField(TEXT("x"), HitResult.ImpactNormal.X);
+			Normal->SetNumberField(TEXT("y"), HitResult.ImpactNormal.Y);
+			Normal->SetNumberField(TEXT("z"), HitResult.ImpactNormal.Z);
+			Result->SetObjectField(TEXT("normal"), Normal);
+		}
+	}
+
+	Result->SetStringField(TEXT("note"),
+		TEXT("height and layer weights come from the landscape's own height and weight data (the merged result of every edit layer), so they are exact and do not depend on collision. traceHeight and normal come from a collision trace and are absent when collision is unbuilt or the proxy is streamed out."));
 	return MCPResult(Result);
 }
 
@@ -876,3 +1478,653 @@ TSharedPtr<FJsonValue> FLandscapeHandlers::FindLandscapeProxyAt(const TSharedPtr
 	Result->SetStringField(TEXT("note"), TEXT("No loaded proxy covers this position; the covering proxy is likely streamed out, so weight/height readbacks here are ambiguous."));
 	return MCPResult(Result);
 }
+
+// Refresh physical-material collision data after a LayerInfo PhysMaterial edit.
+// LayerInfo PostEditChange requests a full edit-layer update as well as an
+// immediate collision recreation. This batch path deliberately separates those
+// operations: it refuses pending edit-layer work, updates layer/material data,
+// waits for the material build, and recreates collision exactly once. Complete
+// raw, complex-live, and simple-live heightfield signatures guard the mutation.
+// Package saving is deliberately outside this action. Only loaded streaming
+// proxies can be acted on; unloaded World Partition actors do not exist here.
+TSharedPtr<FJsonValue> FLandscapeHandlers::RefreshPhysicalMaterialCollision(const TSharedPtr<FJsonObject>& Params)
+{
+#if !UE_MCP_HAS_5_8_API
+	return MCPError(TEXT("Landscape physical-material collision refresh requires Unreal Engine 5.8 or newer"));
+#else
+	const double StartedAt = FPlatformTime::Seconds();
+	if (!GEditor)
+	{
+		return MCPError(TEXT("Editor not available"));
+	}
+	if (GEditor->PlayWorld != nullptr || GEditor->bIsSimulatingInEditor)
+	{
+		return MCPError(TEXT("Stop PIE or SIE before refreshing landscape physical-material collision"));
+	}
+
+	REQUIRE_EDITOR_WORLD(World);
+	if (World->WorldType != EWorldType::Editor)
+	{
+		return MCPError(TEXT("Physical-material collision refresh requires the current editor world"));
+	}
+	if (!World->IsPartitionedWorld())
+	{
+		return MCPError(TEXT("The current editor world is not a World Partition map"));
+	}
+
+	const int32 MaxActors = OptionalInt(Params, TEXT("maxActors"), 256);
+	if (MaxActors < 1 || MaxActors > 1024)
+	{
+		return MCPError(TEXT("'maxActors' must be between 1 and 1024"));
+	}
+	if (OptionalBool(Params, TEXT("save"), false))
+	{
+		return MCPError(TEXT("save_not_supported: this action is in-memory only. Unreal Landscape PreSave can mutate pending edit-layer collision data, so persistence requires a separate validated workflow."));
+	}
+
+	TSet<FString> WantedLabels;
+	const bool bHasLabelFilter = Params->HasField(TEXT("actorLabels"));
+	if (bHasLabelFilter)
+	{
+		const TArray<TSharedPtr<FJsonValue>>* Values = nullptr;
+		if (!Params->TryGetArrayField(TEXT("actorLabels"), Values) || !Values || Values->IsEmpty() || Values->Num() > 256)
+		{
+			return MCPError(TEXT("'actorLabels' must be a non-empty array of at most 256 strings"));
+		}
+		for (const TSharedPtr<FJsonValue>& Value : *Values)
+		{
+			FString Label;
+			if (!Value.IsValid() || !Value->TryGetString(Label) || Label.IsEmpty())
+			{
+				return MCPError(TEXT("Every 'actorLabels' entry must be a non-empty string"));
+			}
+			WantedLabels.Add(Label.ToLower());
+		}
+	}
+
+	TSet<FGuid> WantedGuids;
+	const bool bHasGuidFilter = Params->HasField(TEXT("guids"));
+	if (bHasGuidFilter)
+	{
+		const TArray<TSharedPtr<FJsonValue>>* Values = nullptr;
+		if (!Params->TryGetArrayField(TEXT("guids"), Values) || !Values || Values->IsEmpty() || Values->Num() > 256)
+		{
+			return MCPError(TEXT("'guids' must be a non-empty array of at most 256 GUID strings"));
+		}
+		for (const TSharedPtr<FJsonValue>& Value : *Values)
+		{
+			FString GuidText;
+			FGuid Guid;
+			if (!Value.IsValid() || !Value->TryGetString(GuidText) || !FGuid::Parse(GuidText, Guid))
+			{
+				return MCPError(FString::Printf(TEXT("Invalid actor GUID: '%s'"), *GuidText));
+			}
+			WantedGuids.Add(Guid);
+		}
+	}
+
+	FBox FilterBounds(ForceInit);
+	const bool bHasBoundsFilter = Params->HasField(TEXT("bounds"));
+	if (bHasBoundsFilter)
+	{
+		const TSharedPtr<FJsonObject>* BoundsObject = nullptr;
+		const TSharedPtr<FJsonObject>* MinObject = nullptr;
+		const TSharedPtr<FJsonObject>* MaxObject = nullptr;
+		if (!Params->TryGetObjectField(TEXT("bounds"), BoundsObject) || !BoundsObject ||
+			!(*BoundsObject)->TryGetObjectField(TEXT("min"), MinObject) || !MinObject ||
+			!(*BoundsObject)->TryGetObjectField(TEXT("max"), MaxObject) || !MaxObject)
+		{
+			return MCPError(TEXT("'bounds' must be {min:{x,y,z}, max:{x,y,z}}"));
+		}
+
+		auto ReadVector = [](const TSharedPtr<FJsonObject>& Object, FVector& Out) -> bool
+		{
+			double X = 0.0, Y = 0.0, Z = 0.0;
+			if (!Object->TryGetNumberField(TEXT("x"), X) ||
+				!Object->TryGetNumberField(TEXT("y"), Y) ||
+				!Object->TryGetNumberField(TEXT("z"), Z) ||
+				!FMath::IsFinite(X) || !FMath::IsFinite(Y) || !FMath::IsFinite(Z))
+			{
+				return false;
+			}
+			Out = FVector(X, Y, Z);
+			return true;
+		};
+
+		FVector Min, Max;
+		if (!ReadVector(*MinObject, Min) || !ReadVector(*MaxObject, Max))
+		{
+			return MCPError(TEXT("Every bounds min/max coordinate must be a finite number"));
+		}
+		FilterBounds = FBox(FVector::Min(Min, Max), FVector::Max(Min, Max));
+	}
+
+	TArray<ALandscapeStreamingProxy*> LoadedProxies;
+	TArray<ALandscapeStreamingProxy*> Matches;
+	for (TActorIterator<ALandscapeStreamingProxy> It(World); It; ++It)
+	{
+		ALandscapeStreamingProxy* Proxy = *It;
+		if (!Proxy || Proxy->GetWorld() != World) continue;
+		LoadedProxies.Add(Proxy);
+
+		if (bHasLabelFilter && !WantedLabels.Contains(Proxy->GetActorLabel().ToLower())) continue;
+		if (bHasGuidFilter && !WantedGuids.Contains(Proxy->GetActorGuid())) continue;
+		if (bHasBoundsFilter)
+		{
+			FVector Origin, Extent;
+			Proxy->GetActorBounds(false, Origin, Extent);
+			if (!FBox::BuildAABB(Origin, Extent).Intersect(FilterBounds)) continue;
+		}
+		Matches.Add(Proxy);
+	}
+
+	if (Matches.Num() > MaxActors)
+	{
+		return MCPError(FString::Printf(
+			TEXT("%d loaded LandscapeStreamingProxy actors matched, above the maxActors limit of %d. Narrow actorLabels/guids/bounds or raise maxActors deliberately."),
+			Matches.Num(), MaxActors));
+	}
+	for (ALandscapeStreamingProxy* Proxy : Matches)
+	{
+		if (UPackage* Package = Proxy ? Proxy->GetPackage() : nullptr)
+		{
+			// A later external save would fully load the package first. Establish the
+			// same object residency before any safety baseline or layer-state test.
+			Package->FullyLoad();
+		}
+	}
+
+	struct FRefreshEntry
+	{
+		TSharedPtr<FJsonObject> Json;
+		ALandscapeStreamingProxy* Proxy = nullptr;
+		ALandscape* ParentLandscape = nullptr;
+		FString PackagePath;
+		FString Error;
+		TArray<FLandscapeHeightCollisionSignature> HeightSignatures;
+		int32 LandscapeComponents = 0;
+		int32 CollisionComponents = 0;
+		int32 IneligibleCollisionComponents = 0;
+		int32 ComponentsWithPendingLayerUpdates = 0;
+		int32 OutdatedBefore = 0;
+		int32 OutdatedAfter = 0;
+		bool bTextureResourcesReady = false;
+		bool bLandscapeLayersUpToDate = false;
+		bool bHeightCollisionVerified = false;
+		bool bRefreshed = false;
+	};
+
+	TArray<FRefreshEntry> Entries;
+	TArray<FString> PackagePaths;
+	TMap<ALandscape*, bool> TextureResourcesReady;
+	TMap<ALandscape*, bool> LandscapeLayersUpToDate;
+	for (ALandscapeStreamingProxy* Proxy : Matches)
+	{
+		ALandscape* ParentLandscape = Proxy ? Proxy->GetLandscapeActor() : nullptr;
+		if (ParentLandscape && !LandscapeLayersUpToDate.Contains(ParentLandscape))
+		{
+			// A LayerInfo PostEditChange requests Update_All. PreSave forcibly
+			// flushes that work; on a stale edit-layer stack this can replace valid
+			// collision heights while the package is already being serialized.
+			// Refuse that state instead of discovering it after overwriting the OFPA
+			// package.
+			LandscapeLayersUpToDate.Add(ParentLandscape, ParentLandscape->IsUpToDate());
+		}
+		if (ParentLandscape && LandscapeLayersUpToDate.FindRef(ParentLandscape) &&
+			!TextureResourcesReady.Contains(ParentLandscape))
+		{
+			// BuildPhysicalMaterial depends on resident weightmaps. Do this once per
+			// parent landscape and wait, instead of letting each proxy make a
+			// best-effort non-blocking request in the same frame.
+			TextureResourcesReady.Add(ParentLandscape, ParentLandscape->PrepareTextureResources(true));
+		}
+	}
+	for (TPair<ALandscape*, bool>& Pair : LandscapeLayersUpToDate)
+	{
+		// Texture preparation is allowed to service queued landscape work. Capture
+		// the state that actually exists immediately before the height baseline.
+		Pair.Value = Pair.Key && Pair.Key->IsUpToDate();
+	}
+
+	int32 Refreshed = 0;
+	int32 CollisionComponentsRefreshed = 0;
+	int32 OutdatedBefore = 0;
+
+	for (ALandscapeStreamingProxy* Proxy : Matches)
+	{
+		FRefreshEntry& Entry = Entries.AddDefaulted_GetRef();
+		Entry.Proxy = Proxy;
+		Entry.ParentLandscape = Proxy->GetLandscapeActor();
+		Entry.bLandscapeLayersUpToDate = Entry.ParentLandscape && LandscapeLayersUpToDate.FindRef(Entry.ParentLandscape);
+		Entry.bTextureResourcesReady = Entry.ParentLandscape && TextureResourcesReady.FindRef(Entry.ParentLandscape);
+		Entry.Json = MakeShared<FJsonObject>();
+		Entry.Json->SetStringField(TEXT("label"), Proxy->GetActorLabel());
+		Entry.Json->SetStringField(TEXT("guid"), Proxy->GetActorGuid().ToString());
+		Entry.Json->SetBoolField(TEXT("landscapeLayersUpToDate"), Entry.bLandscapeLayersUpToDate);
+		Entry.Json->SetBoolField(TEXT("textureResourcesReady"), Entry.bTextureResourcesReady);
+
+		if (UPackage* Package = Proxy->GetPackage())
+		{
+			Entry.PackagePath = Package->GetName();
+			Entry.Json->SetStringField(TEXT("package"), Entry.PackagePath);
+			PackagePaths.AddUnique(Entry.PackagePath);
+		}
+
+		TArray<ULandscapeComponent*> Components;
+		Proxy->GetComponents<ULandscapeComponent>(Components);
+		for (ULandscapeComponent* Component : Components)
+		{
+			if (!Component) continue;
+			++Entry.LandscapeComponents;
+			if (Component && Component->GetLayerUpdateFlagPerMode() != 0)
+			{
+				++Entry.ComponentsWithPendingLayerUpdates;
+			}
+			if (Component && Component->IsRegistered() && Component->GetCollisionComponent())
+			{
+				++Entry.CollisionComponents;
+				FLandscapeHeightCollisionSignature Signature;
+				FString SignatureError;
+				if (CaptureHeightCollisionSignature(Component->GetCollisionComponent(), Signature, SignatureError))
+				{
+					Entry.HeightSignatures.Add(MoveTemp(Signature));
+				}
+				else if (Entry.Error.IsEmpty())
+				{
+					Entry.Error = FString::Printf(TEXT("Height collision preflight failed: %s"), *SignatureError);
+				}
+			}
+			else
+			{
+				++Entry.IneligibleCollisionComponents;
+			}
+		}
+		Entry.Json->SetNumberField(TEXT("landscapeComponents"), Entry.LandscapeComponents);
+		Entry.Json->SetNumberField(TEXT("collisionComponents"), Entry.CollisionComponents);
+		Entry.Json->SetNumberField(TEXT("ineligibleCollisionComponents"), Entry.IneligibleCollisionComponents);
+		Entry.Json->SetNumberField(TEXT("componentsWithPendingLayerUpdates"), Entry.ComponentsWithPendingLayerUpdates);
+		Entry.Json->SetNumberField(TEXT("heightCollisionComponentsCaptured"), Entry.HeightSignatures.Num());
+		if (Entry.Error.IsEmpty())
+		{
+			ValidateLandscapeCollisionPreflight(
+				Entry.LandscapeComponents,
+				Entry.CollisionComponents,
+				Entry.HeightSignatures.Num(),
+				Entry.ComponentsWithPendingLayerUpdates,
+				Entry.bLandscapeLayersUpToDate,
+				Entry.bTextureResourcesReady,
+				Entry.Error);
+		}
+		if (!Entry.Error.IsEmpty())
+		{
+			Entry.Json->SetBoolField(TEXT("refreshed"), false);
+			continue;
+		}
+
+	}
+
+	const bool bBatchHeightPreflightPassed =
+		Entries.Num() == Matches.Num() &&
+		!Entries.ContainsByPredicate([](const FRefreshEntry& Entry)
+		{
+			return !Entry.Error.IsEmpty();
+		});
+	if (!bBatchHeightPreflightPassed)
+	{
+		// The selected proxy set is one safety unit. Updating the apparently-good
+		// subset would leave the loaded landscape internally inconsistent and can
+		// reproduce the stale-cache failure on the next save/reload.
+		for (FRefreshEntry& Entry : Entries)
+		{
+			if (Entry.Error.IsEmpty())
+			{
+				Entry.Error = TEXT("Another matched proxy failed loaded/registered height-collision preflight; no matched proxy was mutated");
+				Entry.Json->SetBoolField(TEXT("refreshed"), false);
+			}
+		}
+	}
+
+	FScopedLandscapePhysicalMaterialRecreateMode RecreateMode;
+	if (!RecreateMode.IsValid())
+	{
+		return MCPError(TEXT("Required console variable landscape.ApplyPhysicalMaterialChangesImmediately was unavailable or could not be forced to zero; a higher-priority override may be active"));
+	}
+
+	for (FRefreshEntry& Entry : Entries)
+	{
+		if (!Entry.Error.IsEmpty()) continue;
+		TArray<ULandscapeComponent*> Components;
+		Entry.Proxy->GetComponents<ULandscapeComponent>(Components);
+		for (ULandscapeComponent* Component : Components)
+		{
+			if (Component && Component->IsRegistered() && Component->GetCollisionComponent())
+			{
+				// UpdateCollisionLayerData invalidates the physical-material task but,
+				// unlike ChangedPhysMaterial, intentionally does not tear down physics
+				// before the asynchronous material output is ready.
+				Component->UpdateCollisionLayerData();
+			}
+		}
+		Entry.OutdatedBefore = Entry.Proxy->GetOudatedPhysicalMaterialComponentsCount();
+		Entry.Json->SetNumberField(TEXT("outdatedBefore"), Entry.OutdatedBefore);
+		// The return type changed between supported UE versions; ignoring it is
+		// intentional. The exported outdated count below is the stable readback.
+		Entry.Proxy->BuildPhysicalMaterial();
+		Entry.bRefreshed = true;
+		Entry.Json->SetBoolField(TEXT("refreshed"), true);
+		++Refreshed;
+		CollisionComponentsRefreshed += Entry.CollisionComponents;
+		OutdatedBefore += Entry.OutdatedBefore;
+	}
+
+	// BuildPhysicalMaterial advances an asynchronous GPU readback. Re-enter the
+	// exported build method after flushing render commands until it finalizes
+	// every matched proxy, or until there is enough time left to return a useful
+	// failure report before the handler's 600-second bridge timeout. Time spent
+	// preparing texture resources counts too.
+	const double BuildDeadline = StartedAt + 420.0;
+	bool bBuildTimedOut = false;
+	while (Refreshed > 0)
+	{
+		int32 Remaining = 0;
+		for (const FRefreshEntry& Entry : Entries)
+		{
+			if (Entry.bRefreshed) Remaining += Entry.Proxy->GetOudatedPhysicalMaterialComponentsCount();
+		}
+		if (Remaining == 0) break;
+		if (FPlatformTime::Seconds() >= BuildDeadline)
+		{
+			bBuildTimedOut = true;
+			break;
+		}
+
+		FlushRenderingCommands();
+		for (FRefreshEntry& Entry : Entries)
+		{
+			if (Entry.bRefreshed && Entry.Proxy->GetOudatedPhysicalMaterialComponentsCount() > 0)
+			{
+				Entry.Proxy->BuildPhysicalMaterial();
+			}
+		}
+		FPlatformProcess::Sleep(0.001f);
+	}
+	if (Refreshed > 0) FlushRenderingCommands();
+
+	int32 CollisionComponentsRecreateRequested = 0;
+	int32 CollisionComponentsRecreatedAfterBuild = 0;
+	int32 CollisionComponentsUnchangedAfterBuild = 0;
+	int32 OutdatedAfterBuild = 0;
+	auto VerifyEntryHeightCollision = [](
+		FRefreshEntry& Entry,
+		const TCHAR* Phase,
+		bool bWriteJsonField) -> bool
+	{
+		for (const FLandscapeHeightCollisionSignature& Baseline : Entry.HeightSignatures)
+		{
+			if (!IsValid(Baseline.Collision))
+			{
+				Entry.Error = FString::Printf(
+					TEXT("Height collision verification failed %s: %s is no longer valid"),
+					Phase, *Baseline.ComponentPath);
+				if (bWriteJsonField) Entry.Json->SetBoolField(TEXT("heightCollisionVerified"), false);
+				return false;
+			}
+
+			FLandscapeHeightCollisionSignature Current;
+			FString SignatureError;
+			if (!CaptureHeightCollisionSignature(Baseline.Collision, Current, SignatureError) ||
+				!MatchesHeightCollisionSignature(Baseline, Current, SignatureError))
+			{
+				Entry.Error = FString::Printf(
+					TEXT("Height collision verification failed %s: %s"), Phase, *SignatureError);
+				if (bWriteJsonField) Entry.Json->SetBoolField(TEXT("heightCollisionVerified"), false);
+				return false;
+			}
+		}
+		if (bWriteJsonField) Entry.Json->SetBoolField(TEXT("heightCollisionVerified"), true);
+		return true;
+	};
+
+	for (FRefreshEntry& Entry : Entries)
+	{
+		if (!Entry.bRefreshed) continue;
+		Entry.OutdatedAfter = Entry.Proxy->GetOudatedPhysicalMaterialComponentsCount();
+		Entry.Json->SetNumberField(TEXT("outdatedAfterBuild"), Entry.OutdatedAfter);
+		Entry.Json->SetBoolField(TEXT("physicalMaterialCurrentAfterBuild"), Entry.OutdatedAfter == 0);
+		OutdatedAfterBuild += Entry.OutdatedAfter;
+		if (Entry.OutdatedAfter == 0)
+		{
+			// Prove that the material build did not touch raw or live heights before
+			// tearing down the valid heightfield. The scoped CVar above prevents the
+			// engine finalizer from recreating it early.
+			if (!VerifyEntryHeightCollision(Entry, TEXT("after the physical-material build"), false))
+			{
+				continue;
+			}
+
+			// Recreate exactly once, after both dominant-layer and rendered physical
+			// material data are current. RecreateCollision's return value only says
+			// whether a request was made; the full live height tile below is proof
+			// that a valid, unchanged geometry was produced.
+			int32 EntryRecreateRequested = 0;
+			int32 EntryRecreated = 0;
+			int32 EntryUnchanged = 0;
+			for (const FLandscapeHeightCollisionSignature& Baseline : Entry.HeightSignatures)
+			{
+				if (IsValid(Baseline.Collision) && Baseline.Collision->IsRegistered())
+				{
+					++EntryRecreateRequested;
+					if (Baseline.Collision->RecreateCollision()) ++EntryRecreated;
+					else ++EntryUnchanged;
+				}
+			}
+			Entry.Json->SetNumberField(TEXT("collisionRecreateRequestedAfterBuild"), EntryRecreateRequested);
+			Entry.Json->SetNumberField(TEXT("collisionRecreatedAfterBuild"), EntryRecreated);
+			Entry.Json->SetNumberField(TEXT("collisionUnchangedAfterBuild"), EntryUnchanged);
+			CollisionComponentsRecreateRequested += EntryRecreateRequested;
+			CollisionComponentsRecreatedAfterBuild += EntryRecreated;
+			CollisionComponentsUnchangedAfterBuild += EntryUnchanged;
+			Entry.bHeightCollisionVerified =
+				EntryRecreateRequested == Entry.HeightSignatures.Num() &&
+				EntryRecreated == Entry.HeightSignatures.Num() &&
+				VerifyEntryHeightCollision(Entry, TEXT("after the final collision recreation"), true);
+			if (!Entry.bHeightCollisionVerified && Entry.Error.IsEmpty())
+			{
+				Entry.Error = TEXT("Not every captured collision component was explicitly recreated for the new physical-material mapping");
+				Entry.Json->SetBoolField(TEXT("heightCollisionVerified"), false);
+			}
+		}
+		else
+		{
+			Entry.Error = FString::Printf(
+				TEXT("Physical-material build did not flush %d outdated component(s)%s"),
+				Entry.OutdatedAfter, bBuildTimedOut ? TEXT(" before the timeout") : TEXT(""));
+		}
+	}
+
+	// Read back after the build/recreation so the response reflects the final
+	// in-memory derived state. Persistence is deliberately unsupported here:
+	// ALandscapeProxy::PreSave can mutate edit-layer collision data.
+	int32 OutdatedAfter = 0;
+	int32 PhysicalMaterialsCurrent = 0;
+	for (FRefreshEntry& Entry : Entries)
+	{
+		if (!Entry.bRefreshed) continue;
+		Entry.OutdatedAfter = Entry.Proxy->GetOudatedPhysicalMaterialComponentsCount();
+		Entry.Json->SetNumberField(TEXT("outdatedAfter"), Entry.OutdatedAfter);
+		const bool bPhysicalMaterialCurrent = Entry.OutdatedAfter == 0;
+		Entry.Json->SetBoolField(TEXT("physicalMaterialCurrent"), bPhysicalMaterialCurrent);
+		OutdatedAfter += Entry.OutdatedAfter;
+		if (bPhysicalMaterialCurrent)
+		{
+			++PhysicalMaterialsCurrent;
+		}
+		else if (Entry.Error.IsEmpty())
+		{
+			Entry.Error = FString::Printf(
+				TEXT("Physical-material state has %d outdated component(s) after the build"),
+				Entry.OutdatedAfter);
+		}
+	}
+	const bool bBatchAccepted = !Matches.IsEmpty() && Entries.Num() == Matches.Num() &&
+		!Entries.ContainsByPredicate([](const FRefreshEntry& Entry)
+		{
+			return !Entry.Error.IsEmpty();
+		});
+	if (!bBatchAccepted)
+	{
+		for (FRefreshEntry& Entry : Entries)
+		{
+			if (Entry.Error.IsEmpty())
+			{
+				Entry.Error = TEXT("Another matched proxy failed the post-build safety check; the matched batch was not accepted and must not be saved");
+			}
+		}
+	}
+
+	TArray<TSharedPtr<FJsonValue>> ActorResults;
+	TArray<FString> FailedPackagePaths;
+	int32 Failed = 0;
+	int32 HeightCollisionComponentsVerified = 0;
+	for (FRefreshEntry& Entry : Entries)
+	{
+		Entry.Json->SetBoolField(TEXT("saved"), false);
+		if (Entry.bHeightCollisionVerified)
+		{
+			HeightCollisionComponentsVerified += Entry.HeightSignatures.Num();
+		}
+		if (!Entry.Error.IsEmpty())
+		{
+			++Failed;
+			Entry.Json->SetStringField(TEXT("error"), Entry.Error);
+			if (!Entry.PackagePath.IsEmpty()) FailedPackagePaths.AddUnique(Entry.PackagePath);
+		}
+		ActorResults.Add(MakeShared<FJsonValueObject>(Entry.Json));
+	}
+
+	auto ToJsonStrings = [](const TArray<FString>& Strings)
+	{
+		TArray<TSharedPtr<FJsonValue>> Values;
+		Values.Reserve(Strings.Num());
+		for (const FString& String : Strings) Values.Add(MakeShared<FJsonValueString>(String));
+		return Values;
+	};
+
+	auto Result = MCPSuccess();
+	if (Failed > 0 || Matches.IsEmpty()) Result->SetBoolField(TEXT("success"), false);
+	if (Refreshed > 0) MCPSetUpdated(Result);
+	Result->SetStringField(TEXT("world"), World->GetPathName());
+	Result->SetBoolField(TEXT("batchAccepted"), bBatchAccepted);
+	Result->SetBoolField(TEXT("saveSupported"), false);
+	Result->SetBoolField(TEXT("saveRequested"), false);
+	Result->SetNumberField(TEXT("maxActors"), MaxActors);
+	Result->SetNumberField(TEXT("loaded"), LoadedProxies.Num());
+	Result->SetNumberField(TEXT("matched"), Matches.Num());
+	Result->SetNumberField(TEXT("refreshed"), Refreshed);
+	Result->SetNumberField(TEXT("collisionComponentsRefreshed"), CollisionComponentsRefreshed);
+	Result->SetNumberField(TEXT("collisionComponentsRecreateRequested"), CollisionComponentsRecreateRequested);
+	Result->SetNumberField(TEXT("collisionComponentsRecreatedAfterBuild"), CollisionComponentsRecreatedAfterBuild);
+	Result->SetNumberField(TEXT("collisionComponentsUnchangedAfterBuild"), CollisionComponentsUnchangedAfterBuild);
+	Result->SetNumberField(TEXT("heightCollisionComponentsVerified"), HeightCollisionComponentsVerified);
+	Result->SetNumberField(TEXT("physicalMaterialsCurrent"), PhysicalMaterialsCurrent);
+	Result->SetNumberField(TEXT("outdatedBefore"), OutdatedBefore);
+	Result->SetNumberField(TEXT("outdatedAfterBuild"), OutdatedAfterBuild);
+	Result->SetNumberField(TEXT("outdatedAfter"), OutdatedAfter);
+	Result->SetBoolField(TEXT("buildTimedOut"), bBuildTimedOut);
+	Result->SetNumberField(TEXT("textureResourceParents"), TextureResourcesReady.Num());
+	int32 ReadyParents = 0;
+	for (const TPair<ALandscape*, bool>& Pair : TextureResourcesReady) ReadyParents += Pair.Value ? 1 : 0;
+	Result->SetNumberField(TEXT("textureResourceParentsReady"), ReadyParents);
+	int32 UpToDateParents = 0;
+	for (const TPair<ALandscape*, bool>& Pair : LandscapeLayersUpToDate) UpToDateParents += Pair.Value ? 1 : 0;
+	Result->SetNumberField(TEXT("landscapeLayerParents"), LandscapeLayersUpToDate.Num());
+	Result->SetNumberField(TEXT("landscapeLayerParentsUpToDate"), UpToDateParents);
+	Result->SetNumberField(TEXT("saved"), 0);
+	Result->SetNumberField(TEXT("failed"), Failed);
+	Result->SetArrayField(TEXT("packagePaths"), ToJsonStrings(PackagePaths));
+	Result->SetArrayField(TEXT("savedPackagePaths"), TArray<TSharedPtr<FJsonValue>>());
+	Result->SetArrayField(TEXT("failedPackagePaths"), ToJsonStrings(FailedPackagePaths));
+	Result->SetArrayField(TEXT("actors"), ActorResults);
+	FString Note;
+	if (Matches.IsEmpty())
+	{
+		Note = TEXT("No loaded LandscapeStreamingProxy actor matched. Unloaded proxies were not changed; pin them first with level(load_actor_descs), then rerun this action.");
+	}
+	else if (Failed > 0)
+	{
+		Note = FString::Printf(TEXT("%d of %d matched proxies failed; inspect the per-actor errors. Unloaded proxies were not changed."), Failed, Matches.Num());
+	}
+	else
+	{
+		Note = TEXT("Collision and physical-material data were rebuilt in memory and matched packages may now be dirty. No packages were saved. Unloaded proxies were not changed.");
+	}
+	Result->SetStringField(TEXT("note"), Note);
+	return MCPResult(Result);
+#endif // UE_MCP_HAS_5_8_API
+}
+
+#if WITH_DEV_AUTOMATION_TESTS && UE_MCP_HAS_5_8_API
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FMCPLandscapePhysicalMaterialCollisionHeightSafetyTest,
+	"UE.MCP.Landscape.PhysicalMaterialCollision.HeightSafety",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FMCPLandscapePhysicalMaterialCollisionHeightSafetyTest::RunTest(const FString& Parameters)
+{
+	const TArray<uint16> TerrainRaw = {
+		32768, 32896, 32640, 33024,
+		32768, 32960, 32576, 33152
+	};
+	const TArray<float> TerrainLive = {
+		100.0f, 200.0f, 0.0f, 300.0f,
+		100.0f, 250.0f, -50.0f, 400.0f
+	};
+	const FTransform Transform(FRotator::ZeroRotator, FVector(0.0, 0.0, 100.0), FVector(100.0));
+
+	FLandscapeHeightCollisionSignature Baseline;
+	FString Error;
+	TestTrue(TEXT("varied raw terrain agrees with its complex and simple live heightfields"),
+		BuildHeightCollisionSignature(TerrainRaw, 4, 2, 4, 2, TerrainLive, Transform, Baseline, Error));
+	TestTrue(TEXT("baseline reports a non-flat height range"),
+		Baseline.LiveMaxWorldZ > Baseline.LiveMinWorldZ);
+
+	const TArray<uint16> FlatRaw = {
+		32768, 32768, 32768, 32768,
+		32768, 32768, 32768, 32768
+	};
+	FLandscapeHeightCollisionSignature Invalid;
+	Error.Reset();
+	TestFalse(TEXT("flat raw data cannot masquerade as the original live terrain"),
+		BuildHeightCollisionSignature(FlatRaw, 4, 2, 4, 2, TerrainLive, Transform, Invalid, Error));
+	TestTrue(TEXT("raw/live mismatch names the unsafe sample"), Error.Contains(TEXT("mismatch at sample")));
+
+	TArray<float> FlatSimpleLive = TerrainLive;
+	for (int32 Index = 4; Index < FlatSimpleLive.Num(); ++Index) FlatSimpleLive[Index] = 100.0f;
+	Error.Reset();
+	TestFalse(TEXT("flattened simple live collision is rejected"),
+		BuildHeightCollisionSignature(TerrainRaw, 4, 2, 4, 2, FlatSimpleLive, Transform, Invalid, Error));
+
+	const TArray<float> FlatLive = {
+		100.0f, 100.0f, 100.0f, 100.0f,
+		100.0f, 100.0f, 100.0f, 100.0f
+	};
+	FLandscapeHeightCollisionSignature Flattened;
+	Error.Reset();
+	TestTrue(TEXT("internally consistent flat collision can be signed"),
+		BuildHeightCollisionSignature(FlatRaw, 4, 2, 4, 2, FlatLive, Transform, Flattened, Error));
+	TestFalse(TEXT("a flattened raw/live pair cannot match the terrain baseline"),
+		MatchesHeightCollisionSignature(Baseline, Flattened, Error));
+
+	FString PreflightError;
+	TestFalse(TEXT("pending edit-layer work fails preflight"),
+		ValidateLandscapeCollisionPreflight(1, 1, 1, 1, true, true, PreflightError));
+	TestTrue(TEXT("pending-work failure explains PreSave risk"),
+		PreflightError.Contains(TEXT("pending edit-layer updates")));
+	PreflightError.Reset();
+	TestTrue(TEXT("complete idle collision coverage passes preflight"),
+		ValidateLandscapeCollisionPreflight(1, 1, 1, 0, true, true, PreflightError));
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS && UE_MCP_HAS_5_8_API