ue-mcp 1.2.4 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/SequencerHandlers_Internal.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonObject.h"
+#include "Misc/FrameRate.h"
+#include "MovieSceneTimeHelpers.h"
+
+namespace UEMCP::SequencerInfo
+{
+	inline constexpr int32 MaxDetailedSections = 256;
+	inline constexpr int32 MaxDetailedChannels = 1024;
+	inline constexpr int32 MaxDetailedKeyTimes = 4096;
+	inline constexpr int32 MaxKeyTimesPerChannel = 256;
+
+	struct FDetailBudget
+	{
+		int32 Sections = MaxDetailedSections;
+		int32 Channels = MaxDetailedChannels;
+		int32 KeyTimes = MaxDetailedKeyTimes;
+		bool bTruncated = false;
+	};
+
+	inline void SetFrameRateFields(FJsonObject& Json, const FFrameRate& Rate)
+	{
+		Json.SetNumberField(TEXT("numerator"), Rate.Numerator);
+		Json.SetNumberField(TEXT("denominator"), Rate.Denominator);
+	}
+
+	inline bool IsUsableFrameRate(const FFrameRate& Rate)
+	{
+		return Rate.Numerator > 0 && Rate.Denominator > 0;
+	}
+
+	inline double TickToDisplayFrame(
+		const FFrameNumber Tick,
+		const FFrameRate& TickResolution,
+		const FFrameRate& DisplayRate)
+	{
+		return FFrameRate::TransformTime(FFrameTime(Tick), TickResolution, DisplayRate).AsDecimal();
+	}
+
+	inline void SetTimingRangeFields(
+		FJsonObject& Json,
+		const TRange<FFrameNumber>& Range,
+		const FFrameRate& TickResolution,
+		const FFrameRate& DisplayRate)
+	{
+		const bool bHasStart = Range.HasLowerBound();
+		const bool bHasEnd = Range.HasUpperBound();
+		Json.SetBoolField(TEXT("hasStart"), bHasStart);
+		Json.SetBoolField(TEXT("hasEnd"), bHasEnd);
+
+		if (bHasStart)
+		{
+			const FFrameNumber StartTick = UE::MovieScene::DiscreteInclusiveLower(Range);
+			Json.SetBoolField(TEXT("startInclusive"), true);
+			Json.SetNumberField(TEXT("startTick"), StartTick.Value);
+			Json.SetNumberField(TEXT("startDisplayFrame"), TickToDisplayFrame(StartTick, TickResolution, DisplayRate));
+			Json.SetNumberField(TEXT("startSeconds"), TickResolution.AsSeconds(FFrameTime(StartTick)));
+		}
+
+		if (bHasEnd)
+		{
+			const FFrameNumber EndTick = UE::MovieScene::DiscreteExclusiveUpper(Range);
+			Json.SetBoolField(TEXT("endExclusive"), true);
+			Json.SetNumberField(TEXT("endTick"), EndTick.Value);
+			Json.SetNumberField(TEXT("endDisplayFrame"), TickToDisplayFrame(EndTick, TickResolution, DisplayRate));
+			Json.SetNumberField(TEXT("endSeconds"), TickResolution.AsSeconds(FFrameTime(EndTick)));
+		}
+	}
+
+	inline TSharedPtr<FJsonObject> MakeKeyTimeObject(
+		const FFrameNumber Tick,
+		const FFrameRate& TickResolution,
+		const FFrameRate& DisplayRate)
+	{
+		TSharedPtr<FJsonObject> KeyTime = MakeShared<FJsonObject>();
+		KeyTime->SetNumberField(TEXT("tick"), Tick.Value);
+		KeyTime->SetNumberField(TEXT("displayFrame"), TickToDisplayFrame(Tick, TickResolution, DisplayRate));
+		KeyTime->SetNumberField(TEXT("seconds"), TickResolution.AsSeconds(FFrameTime(Tick)));
+		return KeyTime;
+	}
+}

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

@@ -0,0 +1,200 @@
+#include "SkeletalMeshHandlers.h"
+
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+
+#include "Engine/SkeletalMesh.h"
+#include "SkeletalMeshEditorSubsystem.h"
+
+namespace
+{
+	struct FTargetLod
+	{
+		int32 Index = INDEX_NONE;
+		FSkeletalMeshBuildSettings Before;
+	};
+
+	TSharedPtr<FJsonValue> ResolveTargetLods(
+		const TSharedPtr<FJsonObject>& Params,
+		USkeletalMesh* Mesh,
+		TArray<FTargetLod>& OutLods)
+	{
+		if (!Mesh) return MCPError(TEXT("SkeletalMesh is null"));
+		const int32 LodCount = Mesh->GetLODNum();
+		if (LodCount <= 0) return MCPError(TEXT("SkeletalMesh has no LODs"));
+
+		const bool bAllLods = OptionalBool(Params, TEXT("allLods"), false);
+		if (bAllLods && Params->HasField(TEXT("lodIndex")))
+		{
+			return MCPError(TEXT("Specify either allLods=true or lodIndex, not both"));
+		}
+
+		TArray<int32> Indices;
+		if (bAllLods)
+		{
+			for (int32 Index = 0; Index < LodCount; ++Index) Indices.Add(Index);
+		}
+		else
+		{
+			int32 LodIndex = 0;
+			if (Params->HasField(TEXT("lodIndex")))
+			{
+				double LodNumber = 0.0;
+				if (!Params->TryGetNumberField(TEXT("lodIndex"), LodNumber)
+					|| !FMath::IsFinite(LodNumber)
+					|| !FMath::IsNearlyEqual(LodNumber, FMath::RoundToDouble(LodNumber)))
+				{
+					return MCPError(TEXT("lodIndex must be a finite integer"));
+				}
+				if (LodNumber < static_cast<double>(MIN_int32) || LodNumber > static_cast<double>(MAX_int32))
+				{
+					return MCPError(TEXT("lodIndex is outside the supported integer range"));
+				}
+				LodIndex = static_cast<int32>(LodNumber);
+			}
+			Indices.Add(LodIndex);
+		}
+
+		for (const int32 Index : Indices)
+		{
+			if (Index < 0 || Index >= LodCount)
+			{
+				return MCPError(FString::Printf(TEXT("Invalid lodIndex %d; mesh has %d LODs"), Index, LodCount));
+			}
+			FTargetLod& Target = OutLods.AddDefaulted_GetRef();
+			Target.Index = Index;
+			USkeletalMeshEditorSubsystem::GetLodBuildSettings(Mesh, Index, Target.Before);
+		}
+		return nullptr;
+	}
+
+	TSharedPtr<FJsonObject> SerializeBuildSettings(const FSkeletalMeshBuildSettings& Settings)
+	{
+		auto Out = MakeShared<FJsonObject>();
+		Out->SetBoolField(TEXT("bRecomputeNormals"), Settings.bRecomputeNormals);
+		Out->SetBoolField(TEXT("bRecomputeTangents"), Settings.bRecomputeTangents);
+		Out->SetBoolField(TEXT("bUseMikkTSpace"), Settings.bUseMikkTSpace);
+		Out->SetBoolField(TEXT("bComputeWeightedNormals"), Settings.bComputeWeightedNormals);
+		Out->SetBoolField(TEXT("bRemoveDegenerates"), Settings.bRemoveDegenerates);
+		Out->SetBoolField(TEXT("bUseHighPrecisionTangentBasis"), Settings.bUseHighPrecisionTangentBasis);
+		Out->SetBoolField(TEXT("bUseHighPrecisionSkinWeights"), Settings.bUseHighPrecisionSkinWeights);
+		Out->SetBoolField(TEXT("bUseFullPrecisionUVs"), Settings.bUseFullPrecisionUVs);
+		Out->SetBoolField(TEXT("bUseBackwardsCompatibleF16TruncUVs"), Settings.bUseBackwardsCompatibleF16TruncUVs);
+		Out->SetBoolField(TEXT("bOptimizeForInstancing"), Settings.bOptimizeForInstancing);
+		Out->SetNumberField(TEXT("thresholdPosition"), Settings.ThresholdPosition);
+		Out->SetNumberField(TEXT("thresholdTangentNormal"), Settings.ThresholdTangentNormal);
+		Out->SetNumberField(TEXT("thresholdUV"), Settings.ThresholdUV);
+		Out->SetNumberField(TEXT("morphThresholdPosition"), Settings.MorphThresholdPosition);
+		Out->SetNumberField(TEXT("boneInfluenceLimit"), Settings.BoneInfluenceLimit);
+		return Out;
+	}
+
+	TSharedPtr<FJsonObject> MakeLodResult(int32 Index, const FSkeletalMeshBuildSettings& Before, const FSkeletalMeshBuildSettings& After)
+	{
+		auto Lod = MakeShared<FJsonObject>();
+		Lod->SetNumberField(TEXT("lodIndex"), Index);
+		Lod->SetObjectField(TEXT("beforeBuildSettings"), SerializeBuildSettings(Before));
+		Lod->SetObjectField(TEXT("afterBuildSettings"), SerializeBuildSettings(After));
+		Lod->SetBoolField(TEXT("beforeOptimizeForInstancing"), Before.bOptimizeForInstancing);
+		Lod->SetBoolField(TEXT("afterOptimizeForInstancing"), After.bOptimizeForInstancing);
+		Lod->SetBoolField(TEXT("changed"), Before.bOptimizeForInstancing != After.bOptimizeForInstancing);
+		return Lod;
+	}
+}
+void FSkeletalMeshHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	Registry.RegisterHandler(TEXT("set_skeletal_mesh_optimize_for_instancing"), &SetOptimizeForInstancing);
+	Registry.RegisterHandler(TEXT("read_skeletal_mesh_build_settings"), &ReadBuildSettings);
+}
+
+TSharedPtr<FJsonValue> FSkeletalMeshHandlers::ReadBuildSettings(const TSharedPtr<FJsonObject>& Params)
+{
+	FString AssetPath;
+	if (auto Err = RequireString(Params, TEXT("assetPath"), AssetPath)) return Err;
+	USkeletalMesh* Mesh = LoadAssetByPath<USkeletalMesh>(AssetPath);
+	if (!Mesh) return MCPError(FString::Printf(TEXT("SkeletalMesh not found: %s"), *AssetPath));
+
+	TArray<FTargetLod> Targets;
+	if (TSharedPtr<FJsonValue> Error = ResolveTargetLods(Params, Mesh, Targets)) return Error;
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("assetPath"), Mesh->GetPathName());
+	Result->SetNumberField(TEXT("lodCount"), Mesh->GetLODNum());
+	TArray<TSharedPtr<FJsonValue>> Lods;
+	for (const FTargetLod& Target : Targets)
+	{
+		Lods.Add(MakeShared<FJsonValueObject>(MakeLodResult(Target.Index, Target.Before, Target.Before)));
+	}
+	Result->SetArrayField(TEXT("lods"), Lods);
+	return MCPResult(Result);
+}
+
+TSharedPtr<FJsonValue> FSkeletalMeshHandlers::SetOptimizeForInstancing(const TSharedPtr<FJsonObject>& Params)
+{
+	FString AssetPath;
+	if (auto Err = RequireString(Params, TEXT("assetPath"), AssetPath)) return Err;
+	bool bEnabled = false;
+	if (!Params->TryGetBoolField(TEXT("enabled"), bEnabled))
+	{
+		return MCPError(TEXT("Missing required parameter 'enabled'"));
+	}
+
+	USkeletalMesh* Mesh = LoadAssetByPath<USkeletalMesh>(AssetPath);
+	if (!Mesh) return MCPError(FString::Printf(TEXT("SkeletalMesh not found: %s"), *AssetPath));
+
+	TArray<FTargetLod> Targets;
+	if (TSharedPtr<FJsonValue> Error = ResolveTargetLods(Params, Mesh, Targets)) return Error;
+
+	bool bNeedsMutation = false;
+	for (const FTargetLod& Target : Targets)
+	{
+		if (Target.Before.bOptimizeForInstancing != bEnabled)
+		{
+			bNeedsMutation = true;
+			break;
+		}
+	}
+
+	TArray<TSharedPtr<FJsonValue>> Lods;
+	int32 ChangedLodCount = 0;
+	if (bNeedsMutation)
+	{
+		// Establish the transaction before the first setter. The subsystem also
+		// protects its scoped rebuild, but this preserves the handler's explicit
+		// mutation boundary for undo/redo and fail-closed preflight behavior.
+		Mesh->Modify();
+		for (const FTargetLod& Target : Targets)
+		{
+			if (Target.Before.bOptimizeForInstancing != bEnabled)
+			{
+				++ChangedLodCount;
+				FSkeletalMeshBuildSettings Updated = Target.Before;
+				Updated.bOptimizeForInstancing = bEnabled;
+				USkeletalMeshEditorSubsystem::SetLodBuildSettings(Mesh, Target.Index, Updated);
+			}
+			FSkeletalMeshBuildSettings After;
+			USkeletalMeshEditorSubsystem::GetLodBuildSettings(Mesh, Target.Index, After);
+			Lods.Add(MakeShared<FJsonValueObject>(MakeLodResult(Target.Index, Target.Before, After)));
+		}
+		if (!SaveAssetPackage(Mesh))
+		{
+			return MCPError(FString::Printf(TEXT("Failed to save SkeletalMesh: %s"), *Mesh->GetPathName()));
+		}
+	}
+	else
+	{
+		for (const FTargetLod& Target : Targets)
+		{
+			Lods.Add(MakeShared<FJsonValueObject>(MakeLodResult(Target.Index, Target.Before, Target.Before)));
+		}
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("assetPath"), Mesh->GetPathName());
+	Result->SetBoolField(TEXT("enabled"), bEnabled);
+	Result->SetBoolField(TEXT("updated"), bNeedsMutation);
+	Result->SetBoolField(TEXT("saved"), bNeedsMutation);
+	Result->SetNumberField(TEXT("changedLods"), ChangedLodCount);
+	Result->SetArrayField(TEXT("lods"), Lods);
+	return MCPResult(Result);
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/SkeletalMeshHandlers.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+
+/** Small, editor-only skeletal mesh build-settings handlers. */
+class FSkeletalMeshHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	static TSharedPtr<FJsonValue> SetOptimizeForInstancing(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ReadBuildSettings(const TSharedPtr<FJsonObject>& Params);
+};

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

@@ -19,18 +19,23 @@ void FSplineHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 TSharedPtr<FJsonValue> FSplineHandlers::ReadSpline(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	// #553: support editor or PIE world so runtime spline state is readable.
 	const FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(TEXT("World not available"));
 
-	AActor* Actor = FindActorByLabelOrName(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	// #983: this is the action the report came in on. A level with several
+	// copy-pasted road Blueprints all labelled the same thing answered with
+	// whichever one the actor iterator reached first.
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelOrName;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	// #553: optional componentName to target a specific (custom) spline component
 	// when an actor has more than one. Custom spline subclasses derive from
@@ -57,6 +62,7 @@ TSharedPtr<FJsonValue> FSplineHandlers::ReadSpline(const TSharedPtr<FJsonObject>
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), SplineComp->GetName());
 	Result->SetStringField(TEXT("componentClass"), SplineComp->GetClass()->GetName());
 	Result->SetNumberField(TEXT("splinePointCount"), SplineComp->GetNumberOfSplinePoints());
@@ -140,7 +146,7 @@ TSharedPtr<FJsonValue> FSplineHandlers::ReadSpline(const TSharedPtr<FJsonObject>
 TSharedPtr<FJsonValue> FSplineHandlers::SetSplinePoints(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	const TArray<TSharedPtr<FJsonValue>>* PointsArray = nullptr;
 	if (!Params->TryGetArrayField(TEXT("points"), PointsArray))
@@ -150,11 +156,10 @@ TSharedPtr<FJsonValue> FSplineHandlers::SetSplinePoints(const TSharedPtr<FJsonOb
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	// Find spline component
 	USplineComponent* SplineComp = Actor->FindComponentByClass<USplineComponent>();
@@ -204,12 +209,14 @@ TSharedPtr<FJsonValue> FSplineHandlers::SetSplinePoints(const TSharedPtr<FJsonOb
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetNumberField(TEXT("splinePointCount"), SplineComp->GetNumberOfSplinePoints());
 	Result->SetBoolField(TEXT("closedLoop"), SplineComp->IsClosedLoop());
 	Result->SetNumberField(TEXT("splineLength"), SplineComp->GetSplineLength());
 
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Payload->SetArrayField(TEXT("points"), PrevPoints);
 	Payload->SetBoolField(TEXT("closedLoop"), bPrevClosedLoop);
 	MCPSetRollback(Result, TEXT("set_spline_points"), Payload);

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

@@ -458,9 +458,26 @@ TSharedPtr<FJsonObject> FStateTreeHandlers::SerializeStateHierarchy(const UState
 		if (Trans.State.ID.IsValid())
 		{
 			TransObj->SetStringField(TEXT("targetStateId"), GuidToString(Trans.State.ID));
+			const UStateTreeEditorData* EditorData =
+				Cast<UStateTreeEditorData>(State->GetTypedOuter<UStateTreeEditorData>());
+			if (EditorData)
+			{
+				if (const UStateTreeState* TargetState =
+					EditorData->GetStateByID(Trans.State.ID))
+				{
+					TransObj->SetStringField(
+						TEXT("targetStatePath"),
+						GetStatePath(TargetState));
+				}
+			}
 		}
 
 		TransObj->SetBoolField(TEXT("bEnabled"), Trans.bTransitionEnabled);
+		TransObj->SetBoolField(TEXT("bDelayTransition"), Trans.bDelayTransition);
+		TransObj->SetNumberField(TEXT("delayDuration"), Trans.DelayDuration);
+		TransObj->SetNumberField(
+			TEXT("delayRandomVariance"),
+			Trans.DelayRandomVariance);
 
 		TArray<TSharedPtr<FJsonValue>> TransCondArr;
 		for (const FStateTreeEditorNode& TCond : Trans.Conditions)
@@ -685,7 +702,9 @@ TSharedPtr<FJsonValue> FStateTreeHandlers::ReadStateTree(const TSharedPtr<FJsonO
 
 	if (EditorData->Schema)
 	{
-		Result->SetStringField(TEXT("schemaClass"), EditorData->Schema->GetClass()->GetPathName());
+		const FString SchemaPath = EditorData->Schema->GetClass()->GetPathName();
+		Result->SetStringField(TEXT("schemaClass"), SchemaPath);
+		Result->SetStringField(TEXT("schemaPath"), SchemaPath);
 	}
 
 	// SubTrees (state hierarchy)
@@ -2403,6 +2422,17 @@ TSharedPtr<FJsonValue> FStateTreeHandlers::ValidateStateTree(const TSharedPtr<FJ
 	UStateTreeEditingSubsystem::ValidateStateTree(ST);
 
 	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("assetPath"), ST->GetPathName());
+	if (UStateTreeEditorData* EditorData = GetEditorData(ST))
+	{
+		if (EditorData->Schema)
+		{
+			const FString SchemaPath =
+				EditorData->Schema->GetClass()->GetPathName();
+			Result->SetStringField(TEXT("schemaClass"), SchemaPath);
+			Result->SetStringField(TEXT("schemaPath"), SchemaPath);
+		}
+	}
 	Result->SetBoolField(TEXT("validated"), true);
 	return MCPResult(Result);
 }