ue-mcp 1.2.4 → 1.3.0

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

@@ -0,0 +1,933 @@
+// StaticMesh boolean CSG (#916). See AssetHandlers_MeshBoolean.h for why this
+// is its own translation unit and why GeometryScripting is reached by
+// reflection rather than linked.
+//
+// Everything below drives four Geometry Script entry points that this module
+// does not link against:
+//
+//   GeometryScriptLibrary_StaticMeshFunctions::CopyMeshFromStaticMeshV2
+//   GeometryScriptLibrary_MeshBooleanFunctions::ApplyMeshBoolean
+//   GeometryScriptLibrary_StaticMeshFunctions::CopyMeshToStaticMesh
+//   GeometryScriptLibrary_CreateNewAssetFunctions::CreateNewStaticMeshAssetFromMesh
+//
+// They are UFUNCTIONs, so a reflected call reaches them without a Build.cs
+// dependency on the plugin. FMeshBooleanCall below is the whole of that
+// machinery: allocate the function's parameter frame, initialise every
+// parameter to its declared default (which is how the option structs get their
+// engine defaults without this file knowing their layout), overwrite the ones
+// this handler has an opinion about by NAME, ProcessEvent, read the outputs
+// back, destroy the frame.
+//
+// Enum values are looked up through their UEnum by name rather than by
+// hardcoded ordinal, so an engine that appends an enumerator cannot silently
+// turn a Subtract into a TrimInside.
+
+#include "AssetHandlers_MeshBoolean.h"
+
+#include "HandlerFunctionCall.h"
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+
+#include "Engine/StaticMesh.h"
+#include "Modules/ModuleManager.h"
+#include "PhysicsEngine/BodySetup.h"
+#include "UObject/Package.h"
+#include "UObject/UnrealType.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+
+namespace
+{
+// ── The Geometry Script surface this handler drives ──────────────────────────
+
+const TCHAR* const GSDynamicMeshClass       = TEXT("/Script/GeometryFramework.DynamicMesh");
+const TCHAR* const GSDebugClass             = TEXT("/Script/GeometryScriptingCore.GeometryScriptDebug");
+const TCHAR* const GSStaticMeshFunctions    = TEXT("/Script/GeometryScriptingCore.GeometryScriptLibrary_StaticMeshFunctions");
+const TCHAR* const GSBooleanFunctions       = TEXT("/Script/GeometryScriptingCore.GeometryScriptLibrary_MeshBooleanFunctions");
+const TCHAR* const GSQueryFunctions         = TEXT("/Script/GeometryScriptingCore.GeometryScriptLibrary_MeshQueryFunctions");
+const TCHAR* const GSCreateAssetFunctions   = TEXT("/Script/GeometryScriptingEditor.GeometryScriptLibrary_CreateNewAssetFunctions");
+const TCHAR* const GSBooleanOperationEnum   = TEXT("/Script/GeometryScriptingCore.EGeometryScriptBooleanOperation");
+const TCHAR* const GSLODTypeEnum            = TEXT("/Script/GeometryScriptingCore.EGeometryScriptLODType");
+
+/** Ask the module system for the Geometry Script modules once. Returns false
+ *  when the plugin is not present or not enabled for this project. */
+bool EnsureGeometryScriptingLoaded()
+{
+	static const TCHAR* const Modules[] = {
+		TEXT("GeometryFramework"),
+		TEXT("GeometryScriptingCore"),
+		TEXT("GeometryScriptingEditor")
+	};
+	for (const TCHAR* Name : Modules)
+	{
+		const FName ModuleName(Name);
+		if (!FModuleManager::Get().IsModuleLoaded(ModuleName))
+		{
+			// LoadModule is the non-fatal form. LoadModuleChecked would take
+			// the editor down for a project that simply does not have the
+			// plugin, which is the exact opposite of what this needs to do.
+			FModuleManager::Get().LoadModule(ModuleName);
+		}
+	}
+	return FindObject<UClass>(nullptr, GSDynamicMeshClass) != nullptr
+		&& FindObject<UClass>(nullptr, GSStaticMeshFunctions) != nullptr
+		&& FindObject<UClass>(nullptr, GSBooleanFunctions) != nullptr;
+}
+
+TSharedPtr<FJsonValue> GeometryScriptingUnavailableError(const FString& Detail)
+{
+	TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+	Obj->SetBoolField(TEXT("success"), false);
+	Obj->SetStringField(TEXT("error"), FString::Printf(
+		TEXT("GeometryScripting plugin not available: %s Enable the 'Geometry Script' plugin ")
+			TEXT("(Edit > Plugins > Geometry Script) and restart the editor, then retry."),
+		*Detail));
+	Obj->SetStringField(TEXT("reason"), TEXT("geometry_scripting_unavailable"));
+	Obj->SetStringField(TEXT("requiredPlugin"), TEXT("GeometryScripting"));
+	return MakeShared<FJsonValueObject>(Obj);
+}
+
+/** A value from a UEnum this module does not link, by enumerator name.
+ *  Returns INDEX_NONE when the enum or the name is not there. */
+int64 GeometryScriptEnumValue(const TCHAR* EnumPath, const FString& EnumeratorName)
+{
+	UEnum* Enum = FindObject<UEnum>(nullptr, EnumPath);
+	if (!Enum) return INDEX_NONE;
+	const int64 Value = Enum->GetValueByNameString(EnumeratorName);
+	return Value;
+}
+
+/**
+ * One reflected call into a class this module does not link against.
+ *
+ * The frame is heap-allocated because a Geometry Script parameter list carries
+ * option structs with arrays in them, so it cannot be a POD blob on the stack
+ * that nobody destroys.
+ */
+struct FMeshBooleanCall
+{
+	UObject* CDO = nullptr;
+	UFunction* Function = nullptr;
+	TArray<uint8> Frame;
+
+	~FMeshBooleanCall() { Release(); }
+
+	FMeshBooleanCall() = default;
+	FMeshBooleanCall(const FMeshBooleanCall&) = delete;
+	FMeshBooleanCall& operator=(const FMeshBooleanCall&) = delete;
+
+	bool Bind(const TCHAR* ClassPath, const TCHAR* FunctionName, FString& OutError)
+	{
+		Release();
+
+		UClass* Class = FindObject<UClass>(nullptr, ClassPath);
+		if (!Class)
+		{
+			OutError = FString::Printf(TEXT("class '%s' is not loaded."), ClassPath);
+			return false;
+		}
+		Function = Class->FindFunctionByName(FName(FunctionName));
+		if (!Function)
+		{
+			OutError = FString::Printf(
+				TEXT("'%s' has no reflected function named '%s' in this engine build."),
+				ClassPath, FunctionName);
+			return false;
+		}
+		CDO = Class->GetDefaultObject();
+		if (!CDO)
+		{
+			OutError = FString::Printf(TEXT("'%s' has no default object to call through."), ClassPath);
+			Function = nullptr;
+			return false;
+		}
+
+		// Zero first, then let every parameter construct itself. That second
+		// step is what gives each option struct its C++ defaults, so this file
+		// only has to name the fields it disagrees with.
+		Frame.SetNumZeroed(FMath::Max<int32>(Function->ParmsSize, 1));
+		for (TFieldIterator<FProperty> It(Function); It && (It->PropertyFlags & CPF_Parm); ++It)
+		{
+			It->InitializeValue_InContainer(Frame.GetData());
+		}
+		return true;
+	}
+
+	void Release()
+	{
+		if (Function && Frame.Num() > 0)
+		{
+			MCPFunctionCall::DestroyFrame(Function, Frame.GetData());
+		}
+		Frame.Reset();
+		Function = nullptr;
+		CDO = nullptr;
+	}
+
+	void Invoke()
+	{
+		if (CDO && Function)
+		{
+			CDO->ProcessEvent(Function, Frame.GetData());
+		}
+	}
+
+	FProperty* Param(const TCHAR* Name) const
+	{
+		return Function ? Function->FindPropertyByName(FName(Name)) : nullptr;
+	}
+
+	bool SetObject(const TCHAR* Name, UObject* Value)
+	{
+		FObjectPropertyBase* Prop = CastField<FObjectPropertyBase>(Param(Name));
+		if (!Prop) return false;
+		Prop->SetObjectPropertyValue_InContainer(Frame.GetData(), Value);
+		return true;
+	}
+
+	bool SetBool(const TCHAR* Name, bool Value)
+	{
+		FBoolProperty* Prop = CastField<FBoolProperty>(Param(Name));
+		if (!Prop) return false;
+		Prop->SetPropertyValue_InContainer(Frame.GetData(), Value);
+		return true;
+	}
+
+	bool SetString(const TCHAR* Name, const FString& Value)
+	{
+		FStrProperty* Prop = CastField<FStrProperty>(Param(Name));
+		if (!Prop) return false;
+		Prop->SetPropertyValue_InContainer(Frame.GetData(), Value);
+		return true;
+	}
+
+	bool SetTransform(const TCHAR* Name, const FTransform& Value)
+	{
+		FStructProperty* Prop = CastField<FStructProperty>(Param(Name));
+		if (!Prop || Prop->Struct != TBaseStructure<FTransform>::Get()) return false;
+		*Prop->ContainerPtrToValuePtr<FTransform>(Frame.GetData()) = Value;
+		return true;
+	}
+
+	bool SetEnum(const TCHAR* Name, int64 Value)
+	{
+		if (Value == INDEX_NONE) return false;
+		FProperty* Prop = Param(Name);
+		if (FEnumProperty* EnumProp = CastField<FEnumProperty>(Prop))
+		{
+			EnumProp->GetUnderlyingProperty()->SetIntPropertyValue(
+				EnumProp->ContainerPtrToValuePtr<void>(Frame.GetData()), Value);
+			return true;
+		}
+		if (FByteProperty* ByteProp = CastField<FByteProperty>(Prop))
+		{
+			ByteProp->SetPropertyValue_InContainer(Frame.GetData(), static_cast<uint8>(Value));
+			return true;
+		}
+		return false;
+	}
+
+	/** Address of one field inside a struct parameter, so an option struct can
+	 *  be filled in without this module knowing its C++ layout. */
+	void* StructField(const TCHAR* ParamName, const TCHAR* FieldName, FProperty*& OutField) const
+	{
+		OutField = nullptr;
+		FStructProperty* Prop = CastField<FStructProperty>(Param(ParamName));
+		if (!Prop || !Prop->Struct) return nullptr;
+		OutField = Prop->Struct->FindPropertyByName(FName(FieldName));
+		if (!OutField) return nullptr;
+		void* StructPtr = Prop->ContainerPtrToValuePtr<void>(const_cast<uint8*>(Frame.GetData()));
+		return OutField->ContainerPtrToValuePtr<void>(StructPtr);
+	}
+
+	bool SetStructBool(const TCHAR* ParamName, const TCHAR* FieldName, bool Value)
+	{
+		FProperty* Field = nullptr;
+		void* Ptr = StructField(ParamName, FieldName, Field);
+		FBoolProperty* BoolProp = CastField<FBoolProperty>(Field);
+		if (!Ptr || !BoolProp) return false;
+		BoolProp->SetPropertyValue(Ptr, Value);
+		return true;
+	}
+
+	bool SetStructNumber(const TCHAR* ParamName, const TCHAR* FieldName, double Value)
+	{
+		FProperty* Field = nullptr;
+		void* Ptr = StructField(ParamName, FieldName, Field);
+		FNumericProperty* NumProp = CastField<FNumericProperty>(Field);
+		if (!Ptr || !NumProp) return false;
+		if (NumProp->IsFloatingPoint())
+		{
+			NumProp->SetFloatingPointPropertyValue(Ptr, Value);
+		}
+		else
+		{
+			NumProp->SetIntPropertyValue(Ptr, static_cast<int64>(Value));
+		}
+		return true;
+	}
+
+	bool SetStructEnum(const TCHAR* ParamName, const TCHAR* FieldName, int64 Value)
+	{
+		if (Value == INDEX_NONE) return false;
+		FProperty* Field = nullptr;
+		void* Ptr = StructField(ParamName, FieldName, Field);
+		if (!Ptr) return false;
+		if (FEnumProperty* EnumProp = CastField<FEnumProperty>(Field))
+		{
+			EnumProp->GetUnderlyingProperty()->SetIntPropertyValue(Ptr, Value);
+			return true;
+		}
+		if (FByteProperty* ByteProp = CastField<FByteProperty>(Field))
+		{
+			ByteProp->SetPropertyValue(Ptr, static_cast<uint8>(Value));
+			return true;
+		}
+		return false;
+	}
+
+	UObject* GetObject(const TCHAR* Name) const
+	{
+		FObjectPropertyBase* Prop = CastField<FObjectPropertyBase>(Param(Name));
+		if (!Prop) return nullptr;
+		return Prop->GetObjectPropertyValue_InContainer(const_cast<uint8*>(Frame.GetData()));
+	}
+
+	int32 GetInt(const TCHAR* Name) const
+	{
+		FNumericProperty* Prop = CastField<FNumericProperty>(Param(Name));
+		if (!Prop) return 0;
+		return static_cast<int32>(Prop->GetSignedIntPropertyValue(
+			Prop->ContainerPtrToValuePtr<void>(const_cast<uint8*>(Frame.GetData()))));
+	}
+
+	/** An enum output as its enumerator name, which is how the Outcome pin is
+	 *  read without depending on Failure being 0 forever. */
+	FString GetEnumName(const TCHAR* Name) const
+	{
+		FProperty* Prop = Param(Name);
+		void* Ptr = Prop ? Prop->ContainerPtrToValuePtr<void>(const_cast<uint8*>(Frame.GetData())) : nullptr;
+		if (!Ptr) return FString();
+		if (FEnumProperty* EnumProp = CastField<FEnumProperty>(Prop))
+		{
+			const int64 Raw = EnumProp->GetUnderlyingProperty()->GetSignedIntPropertyValue(Ptr);
+			return EnumProp->GetEnum() ? EnumProp->GetEnum()->GetNameStringByValue(Raw) : FString();
+		}
+		if (FByteProperty* ByteProp = CastField<FByteProperty>(Prop))
+		{
+			const int64 Raw = ByteProp->GetPropertyValue(Ptr);
+			return ByteProp->Enum ? ByteProp->Enum->GetNameStringByValue(Raw) : FString();
+		}
+		return FString();
+	}
+
+	/** The return value, whatever it is named. */
+	UObject* ReturnObject() const
+	{
+		for (TFieldIterator<FProperty> It(Function); It && (It->PropertyFlags & CPF_Parm); ++It)
+		{
+			if (!(It->PropertyFlags & CPF_ReturnParm)) continue;
+			if (FObjectPropertyBase* Prop = CastField<FObjectPropertyBase>(*It))
+			{
+				return Prop->GetObjectPropertyValue_InContainer(const_cast<uint8*>(Frame.GetData()));
+			}
+		}
+		return nullptr;
+	}
+};
+
+/** Read and clear the messages a UGeometryScriptDebug collected, so the reason
+ *  a boolean failed reaches the caller instead of only the output log. */
+TArray<FString> DrainDebugMessages(UObject* Debug)
+{
+	TArray<FString> Out;
+	if (!Debug) return Out;
+
+	FArrayProperty* ArrayProp = CastField<FArrayProperty>(
+		Debug->GetClass()->FindPropertyByName(FName(TEXT("Messages"))));
+	if (!ArrayProp) return Out;
+
+	FStructProperty* ElementProp = CastField<FStructProperty>(ArrayProp->Inner);
+	if (!ElementProp || !ElementProp->Struct) return Out;
+	FTextProperty* MessageProp = CastField<FTextProperty>(
+		ElementProp->Struct->FindPropertyByName(FName(TEXT("Message"))));
+	if (!MessageProp) return Out;
+
+	FScriptArrayHelper Helper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(Debug));
+	for (int32 Index = 0; Index < Helper.Num(); ++Index)
+	{
+		void* Element = Helper.GetRawPtr(Index);
+		const FString Text = MessageProp->GetPropertyValue(
+			MessageProp->ContainerPtrToValuePtr<void>(Element)).ToString();
+		if (!Text.IsEmpty()) Out.Add(Text);
+	}
+	Helper.EmptyValues();
+	return Out;
+}
+
+void AttachDebugMessages(const TSharedPtr<FJsonObject>& Out, const TArray<FString>& Messages)
+{
+	if (Messages.Num() == 0) return;
+	TArray<TSharedPtr<FJsonValue>> Json;
+	for (const FString& Message : Messages) Json.Add(MakeShared<FJsonValueString>(Message));
+	Out->SetArrayField(TEXT("geometryScriptMessages"), Json);
+}
+
+/** Count triangles and vertices on a DynamicMesh through Geometry Script's own
+ *  query library, which is the only thing that can see inside it from here. */
+bool ReadDynamicMeshCounts(UObject* Mesh, int32& OutTriangles, int32& OutVertices)
+{
+	OutTriangles = 0;
+	OutVertices = 0;
+	if (!Mesh) return false;
+
+	FString Error;
+	FMeshBooleanCall Triangles;
+	if (Triangles.Bind(GSQueryFunctions, TEXT("GetNumTriangleIDs"), Error))
+	{
+		Triangles.SetObject(TEXT("TargetMesh"), Mesh);
+		Triangles.Invoke();
+		OutTriangles = Triangles.GetInt(TEXT("ReturnValue"));
+	}
+	FMeshBooleanCall Vertices;
+	if (Vertices.Bind(GSQueryFunctions, TEXT("GetNumVertexIDs"), Error))
+	{
+		Vertices.SetObject(TEXT("TargetMesh"), Mesh);
+		Vertices.Invoke();
+		OutVertices = Vertices.GetInt(TEXT("ReturnValue"));
+	}
+	return true;
+}
+
+/** Map the caller's operation word to the Geometry Script enumerator.
+ *  Returns an empty string when the word is not one this action accepts. */
+FString ResolveBooleanOperation(const FString& Requested)
+{
+	const FString Lower = Requested.ToLower();
+	if (Lower == TEXT("union") || Lower == TEXT("add") || Lower == TEXT("merge")) return TEXT("Union");
+	if (Lower == TEXT("subtract") || Lower == TEXT("difference") || Lower == TEXT("minus")) return TEXT("Subtract");
+	if (Lower == TEXT("intersect") || Lower == TEXT("intersection")) return TEXT("Intersection");
+	if (Lower == TEXT("triminside")) return TEXT("TrimInside");
+	if (Lower == TEXT("trimoutside")) return TEXT("TrimOutside");
+	if (Lower == TEXT("newpolygroupinside")) return TEXT("NewPolyGroupInside");
+	if (Lower == TEXT("newpolygroupoutside")) return TEXT("NewPolyGroupOutside");
+	return FString();
+}
+
+/** The LOD selector word, defaulting to the highest-quality source available.
+ *  Empty return means the word was not recognised. */
+FString ResolveLODType(const FString& Requested)
+{
+	if (Requested.IsEmpty()) return TEXT("MaxAvailable");
+	const FString Lower = Requested.ToLower();
+	if (Lower == TEXT("maxavailable")) return TEXT("MaxAvailable");
+	if (Lower == TEXT("hiressourcemodel")) return TEXT("HiResSourceModel");
+	if (Lower == TEXT("sourcemodel")) return TEXT("SourceModel");
+	if (Lower == TEXT("renderdata")) return TEXT("RenderData");
+	return FString();
+}
+
+/** The default output path for a boolean whose caller did not name one:
+ *  "/Game/Meshes/SM_Wall" plus "_Subtract". A separate asset is the default on
+ *  purpose, because the destructive form of this operation cannot be undone
+ *  from a result object. */
+FString DeriveOutputPath(const FString& TargetPath, const FString& OperationName)
+{
+	const FMCPAssetPathForms Forms = MCPAssetPathForms(TargetPath);
+	if (Forms.PackagePath.IsEmpty()) return FString();
+	return Forms.PackagePath + TEXT("_") + OperationName;
+}
+
+/** Copy the simple collision shapes and trace flag from one StaticMesh to
+ *  another. A boolean result with no collision at all is a silent trap for
+ *  anything that walks on it, and rebuilding collision from the new geometry is
+ *  a different operation with different tradeoffs. */
+bool CopySimpleCollision(UStaticMesh* From, UStaticMesh* To)
+{
+	if (!From || !To) return false;
+	UBodySetup* SourceSetup = From->GetBodySetup();
+	if (!SourceSetup) return false;
+
+	if (!To->GetBodySetup())
+	{
+		To->CreateBodySetup();
+	}
+	UBodySetup* TargetSetup = To->GetBodySetup();
+	if (!TargetSetup) return false;
+
+	TargetSetup->Modify();
+	TargetSetup->AggGeom = SourceSetup->AggGeom;
+	TargetSetup->CollisionTraceFlag = SourceSetup->CollisionTraceFlag;
+	// Invalidate and leave the cook to the engine's own lazy path. Forcing
+	// CreatePhysicsMeshes here would cook on the game thread for no benefit the
+	// caller can observe from the result.
+	TargetSetup->InvalidatePhysicsData();
+	return true;
+}
+
+void WriteMeshStats(const TSharedPtr<FJsonObject>& Out, const TCHAR* Prefix, UStaticMesh* Mesh)
+{
+	if (!Mesh) return;
+	TSharedPtr<FJsonObject> Stats = MakeShared<FJsonObject>();
+	Stats->SetStringField(TEXT("assetPath"), Mesh->GetPathName());
+	Stats->SetNumberField(TEXT("triangles"), Mesh->GetNumTriangles(0));
+	Stats->SetNumberField(TEXT("vertices"), Mesh->GetNumVertices(0));
+	Stats->SetNumberField(TEXT("lodCount"), Mesh->GetNumLODs());
+	Stats->SetNumberField(TEXT("materialSlots"), Mesh->GetStaticMaterials().Num());
+	const FBoxSphereBounds Bounds = Mesh->GetBounds();
+	Stats->SetObjectField(TEXT("boundsOrigin"), MCPVec3ToJsonObject(Bounds.Origin));
+	Stats->SetObjectField(TEXT("boundsExtent"), MCPVec3ToJsonObject(Bounds.BoxExtent));
+	Out->SetObjectField(Prefix, Stats);
+}
+}
+
+void FAssetMeshBooleanHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	// A boolean over two dense meshes, plus the copy in and the rebuild out, is
+	// minutes rather than milliseconds on a repair-sized asset. The default
+	// handler timeout would report a hang while the editor was still working.
+	Registry.RegisterHandlerWithTimeout(TEXT("mesh_boolean"), &MeshBoolean, 300.0f);
+}
+
+TSharedPtr<FJsonValue> FAssetMeshBooleanHandlers::MeshBoolean(const TSharedPtr<FJsonObject>& Params)
+{
+	MCP_CHECK_GAME_THREAD();
+
+	// ── Parameters ──────────────────────────────────────────────────────────
+	FString RequestedOperation;
+	if (auto Err = RequireString(Params, TEXT("operation"), RequestedOperation)) return Err;
+	const FString OperationName = ResolveBooleanOperation(RequestedOperation);
+	if (OperationName.IsEmpty())
+	{
+		return MCPError(FString::Printf(
+			TEXT("Unknown boolean operation '%s'. Use union, subtract, intersect, trimInside, trimOutside, ")
+				TEXT("newPolyGroupInside or newPolyGroupOutside."),
+			*RequestedOperation));
+	}
+
+	FString TargetPath;
+	if (auto Err = RequireString(Params, TEXT("targetPath"), TargetPath)) return Err;
+	FString ToolPath;
+	if (auto Err = RequireString(Params, TEXT("toolPath"), ToolPath)) return Err;
+
+	const bool bInPlace = OptionalBool(Params, TEXT("inPlace"), false);
+	FString OutputPath = OptionalString(Params, TEXT("outputPath"));
+	if (bInPlace && !OutputPath.IsEmpty())
+	{
+		return MCPError(TEXT("Pass 'outputPath' or 'inPlace', not both: they name two different destinations ")
+			TEXT("and there is no safe answer when they disagree."));
+	}
+	if (bInPlace)
+	{
+		OutputPath = TargetPath;
+	}
+	else if (OutputPath.IsEmpty())
+	{
+		OutputPath = DeriveOutputPath(TargetPath, OperationName);
+		if (OutputPath.IsEmpty())
+		{
+			return MCPError(FString::Printf(
+				TEXT("'%s' is not a usable asset path, so no default output path could be derived from it. ")
+					TEXT("Pass outputPath explicitly."),
+				*TargetPath));
+		}
+	}
+
+	const FString RequestedLODType = OptionalString(Params, TEXT("lodType"));
+	const FString LODTypeName = ResolveLODType(RequestedLODType);
+	if (LODTypeName.IsEmpty())
+	{
+		return MCPError(FString::Printf(
+			TEXT("Unknown lodType '%s'. Use MaxAvailable, HiResSourceModel, SourceModel or RenderData."),
+			*RequestedLODType));
+	}
+	const int32 LODIndex = FMath::Max(0, OptionalInt(Params, TEXT("lodIndex"), 0));
+
+	const bool bFillHoles = OptionalBool(Params, TEXT("fillHoles"), true);
+	const bool bSimplifyOutput = OptionalBool(Params, TEXT("simplifyOutput"), true);
+	const double SimplifyPlanarTolerance = OptionalNumber(Params, TEXT("simplifyPlanarTolerance"), 0.01);
+	const bool bAllowEmptyResult = OptionalBool(Params, TEXT("allowEmptyResult"), false);
+	const bool bRecomputeNormals = OptionalBool(Params, TEXT("recomputeNormals"), false);
+	const bool bRecomputeTangents = OptionalBool(Params, TEXT("recomputeTangents"), false);
+	const bool bRemoveDegenerates = OptionalBool(Params, TEXT("removeDegenerates"), false);
+	const bool bCopyCollision = OptionalBool(Params, TEXT("copyCollisionFromTarget"), true);
+	const bool bCopyMaterials = OptionalBool(Params, TEXT("copyMaterialsFromTarget"), true);
+	const FString NaniteMode = OptionalString(Params, TEXT("nanite"), TEXT("inherit")).ToLower();
+	if (NaniteMode != TEXT("inherit") && NaniteMode != TEXT("enable") && NaniteMode != TEXT("disable"))
+	{
+		return MCPError(FString::Printf(
+			TEXT("Unknown nanite mode '%s'. Use inherit (copy the target's setting), enable or disable."),
+			*NaniteMode));
+	}
+	const bool bDryRun = OptionalBool(Params, TEXT("dryRun"), false);
+	const bool bSave = OptionalBool(Params, TEXT("save"), true);
+	const FString OnConflict = OptionalString(Params, TEXT("onConflict"), TEXT("error")).ToLower();
+	if (OnConflict != TEXT("error") && OnConflict != TEXT("replace"))
+	{
+		return MCPError(FString::Printf(
+			TEXT("Unknown onConflict '%s'. Use error (default) or replace."), *OnConflict));
+	}
+
+	const FTransform TargetTransform = OptionalTransform(Params, TEXT("targetTransform"));
+	const FTransform ToolTransform = OptionalTransform(Params, TEXT("toolTransform"));
+
+	// ── Guardrails ──────────────────────────────────────────────────────────
+	if (MCPIsProtectedAssetPath(OutputPath)) return MCPProtectedPathError(OutputPath);
+
+	if (!EnsureGeometryScriptingLoaded())
+	{
+		return GeometryScriptingUnavailableError(
+			TEXT("its runtime classes are not registered in this editor."));
+	}
+
+	UObject* TargetObject = MCPLoadAssetObject(TargetPath);
+	UStaticMesh* TargetMesh = Cast<UStaticMesh>(TargetObject);
+	if (!TargetMesh)
+	{
+		return TargetObject
+			? MCPAssetWrongTypeError(TargetPath, TargetObject, TEXT("StaticMesh"))
+			: MCPAssetNotFoundError(TargetPath, TEXT("Target mesh"));
+	}
+	UObject* ToolObject = MCPLoadAssetObject(ToolPath);
+	UStaticMesh* ToolMesh = Cast<UStaticMesh>(ToolObject);
+	if (!ToolMesh)
+	{
+		return ToolObject
+			? MCPAssetWrongTypeError(ToolPath, ToolObject, TEXT("StaticMesh"))
+			: MCPAssetNotFoundError(ToolPath, TEXT("Tool mesh"));
+	}
+
+	UObject* OutputObject = MCPLoadAssetObject(OutputPath);
+	UStaticMesh* ExistingOutput = Cast<UStaticMesh>(OutputObject);
+	if (OutputObject && !ExistingOutput)
+	{
+		return MCPAssetWrongTypeError(OutputPath, OutputObject, TEXT("StaticMesh"));
+	}
+	if (ExistingOutput && OnConflict == TEXT("error") && !bInPlace)
+	{
+		return MCPError(FString::Printf(
+			TEXT("'%s' already exists. Pass onConflict='replace' to overwrite it, inPlace=true to write back ")
+				TEXT("into the target, or name a different outputPath."),
+			*OutputPath));
+	}
+
+	// ── Bind everything before anything is built ────────────────────────────
+	UClass* DynamicMeshClass = FindObject<UClass>(nullptr, GSDynamicMeshClass);
+	if (!DynamicMeshClass)
+	{
+		return GeometryScriptingUnavailableError(TEXT("UDynamicMesh is not registered."));
+	}
+
+	FString BindError;
+	FMeshBooleanCall CopyIn;
+	if (!CopyIn.Bind(GSStaticMeshFunctions, TEXT("CopyMeshFromStaticMeshV2"), BindError))
+	{
+		return GeometryScriptingUnavailableError(BindError);
+	}
+	FMeshBooleanCall Boolean;
+	if (!Boolean.Bind(GSBooleanFunctions, TEXT("ApplyMeshBoolean"), BindError))
+	{
+		return GeometryScriptingUnavailableError(BindError);
+	}
+
+	const int64 OperationValue = GeometryScriptEnumValue(GSBooleanOperationEnum, OperationName);
+	if (OperationValue == INDEX_NONE)
+	{
+		return GeometryScriptingUnavailableError(FString::Printf(
+			TEXT("EGeometryScriptBooleanOperation has no '%s' in this engine build."), *OperationName));
+	}
+	const int64 LODTypeValue = GeometryScriptEnumValue(GSLODTypeEnum, LODTypeName);
+
+	// ── Build the two dynamic meshes ────────────────────────────────────────
+	UObject* TargetDynamic = NewObject<UObject>(GetTransientPackage(), DynamicMeshClass);
+	UObject* ToolDynamic = NewObject<UObject>(GetTransientPackage(), DynamicMeshClass);
+	if (!TargetDynamic || !ToolDynamic)
+	{
+		return GeometryScriptingUnavailableError(TEXT("a UDynamicMesh could not be constructed."));
+	}
+	const FGCRootScope KeepTargetDynamic(TargetDynamic);
+	const FGCRootScope KeepToolDynamic(ToolDynamic);
+
+	UObject* Debug = nullptr;
+	if (UClass* DebugClass = FindObject<UClass>(nullptr, GSDebugClass))
+	{
+		Debug = NewObject<UObject>(GetTransientPackage(), DebugClass);
+	}
+	const FGCRootScope KeepDebug(Debug);
+
+	TArray<FString> Messages;
+
+	auto CopyMeshIn = [&](UStaticMesh* From, UObject* To, const FString& FromPath, FString& OutFailure) -> bool
+	{
+		FMeshBooleanCall Call;
+		FString Error;
+		if (!Call.Bind(GSStaticMeshFunctions, TEXT("CopyMeshFromStaticMeshV2"), Error))
+		{
+			OutFailure = Error;
+			return false;
+		}
+		Call.SetObject(TEXT("FromStaticMeshAsset"), From);
+		Call.SetObject(TEXT("ToDynamicMesh"), To);
+		Call.SetStructEnum(TEXT("RequestedLOD"), TEXT("LODType"), LODTypeValue);
+		Call.SetStructNumber(TEXT("RequestedLOD"), TEXT("LODIndex"), LODIndex);
+		Call.SetBool(TEXT("bUseSectionMaterials"), true);
+		Call.SetObject(TEXT("Debug"), Debug);
+		Call.Invoke();
+
+		Messages.Append(DrainDebugMessages(Debug));
+		if (Call.GetEnumName(TEXT("Outcome")) != TEXT("Success"))
+		{
+			OutFailure = FString::Printf(
+				TEXT("reading '%s' at LOD %s[%d] produced no mesh."), *FromPath, *LODTypeName, LODIndex);
+			return false;
+		}
+		return true;
+	};
+
+	FString Failure;
+	if (!CopyMeshIn(TargetMesh, TargetDynamic, TargetPath, Failure))
+	{
+		TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+		Obj->SetBoolField(TEXT("success"), false);
+		Obj->SetStringField(TEXT("error"), FString::Printf(TEXT("Target mesh could not be read: %s"), *Failure));
+		Obj->SetStringField(TEXT("reason"), TEXT("target_read_failed"));
+		AttachDebugMessages(Obj, Messages);
+		return MakeShared<FJsonValueObject>(Obj);
+	}
+	if (!CopyMeshIn(ToolMesh, ToolDynamic, ToolPath, Failure))
+	{
+		TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+		Obj->SetBoolField(TEXT("success"), false);
+		Obj->SetStringField(TEXT("error"), FString::Printf(TEXT("Tool mesh could not be read: %s"), *Failure));
+		Obj->SetStringField(TEXT("reason"), TEXT("tool_read_failed"));
+		AttachDebugMessages(Obj, Messages);
+		return MakeShared<FJsonValueObject>(Obj);
+	}
+
+	int32 TargetTrianglesIn = 0, TargetVerticesIn = 0;
+	int32 ToolTrianglesIn = 0, ToolVerticesIn = 0;
+	ReadDynamicMeshCounts(TargetDynamic, TargetTrianglesIn, TargetVerticesIn);
+	ReadDynamicMeshCounts(ToolDynamic, ToolTrianglesIn, ToolVerticesIn);
+
+	// ── The boolean ─────────────────────────────────────────────────────────
+	Boolean.SetObject(TEXT("TargetMesh"), TargetDynamic);
+	Boolean.SetTransform(TEXT("TargetTransform"), TargetTransform);
+	Boolean.SetObject(TEXT("ToolMesh"), ToolDynamic);
+	Boolean.SetTransform(TEXT("ToolTransform"), ToolTransform);
+	Boolean.SetEnum(TEXT("Operation"), OperationValue);
+	Boolean.SetStructBool(TEXT("Options"), TEXT("bFillHoles"), bFillHoles);
+	Boolean.SetStructBool(TEXT("Options"), TEXT("bSimplifyOutput"), bSimplifyOutput);
+	Boolean.SetStructNumber(TEXT("Options"), TEXT("SimplifyPlanarTolerance"), SimplifyPlanarTolerance);
+	Boolean.SetStructBool(TEXT("Options"), TEXT("bAllowEmptyResult"), bAllowEmptyResult);
+	Boolean.SetObject(TEXT("Debug"), Debug);
+	Boolean.Invoke();
+	Messages.Append(DrainDebugMessages(Debug));
+
+	int32 ResultTriangles = 0, ResultVertices = 0;
+	ReadDynamicMeshCounts(TargetDynamic, ResultTriangles, ResultVertices);
+
+	// ── Validate before writing ─────────────────────────────────────────────
+	if (ResultTriangles == 0 && !bAllowEmptyResult)
+	{
+		TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+		Obj->SetBoolField(TEXT("success"), false);
+		Obj->SetStringField(TEXT("error"), FString::Printf(
+			TEXT("The %s of '%s' and '%s' is empty, so nothing was written. The two meshes may not overlap ")
+				TEXT("in the space the transforms put them in, or the operation may have removed everything. ")
+				TEXT("Pass allowEmptyResult=true if an empty result is what you meant."),
+			*OperationName, *TargetPath, *ToolPath));
+		Obj->SetStringField(TEXT("reason"), TEXT("empty_result"));
+		Obj->SetStringField(TEXT("operation"), OperationName);
+		Obj->SetNumberField(TEXT("resultTriangles"), 0);
+		AttachDebugMessages(Obj, Messages);
+		return MakeShared<FJsonValueObject>(Obj);
+	}
+
+	auto BuildResultBody = [&](const TSharedPtr<FJsonObject>& Out)
+	{
+		Out->SetStringField(TEXT("operation"), OperationName);
+		Out->SetStringField(TEXT("targetPath"), TargetPath);
+		Out->SetStringField(TEXT("toolPath"), ToolPath);
+		Out->SetStringField(TEXT("outputPath"), OutputPath);
+		Out->SetBoolField(TEXT("inPlace"), bInPlace);
+		Out->SetStringField(TEXT("lodType"), LODTypeName);
+		Out->SetNumberField(TEXT("lodIndex"), LODIndex);
+		Out->SetNumberField(TEXT("targetTrianglesIn"), TargetTrianglesIn);
+		Out->SetNumberField(TEXT("targetVerticesIn"), TargetVerticesIn);
+		Out->SetNumberField(TEXT("toolTrianglesIn"), ToolTrianglesIn);
+		Out->SetNumberField(TEXT("toolVerticesIn"), ToolVerticesIn);
+		Out->SetNumberField(TEXT("resultTriangles"), ResultTriangles);
+		Out->SetNumberField(TEXT("resultVertices"), ResultVertices);
+		Out->SetBoolField(TEXT("resultIsEmpty"), ResultTriangles == 0);
+		AttachDebugMessages(Out, Messages);
+	};
+
+	if (bDryRun)
+	{
+		auto Preview = MCPSuccess();
+		BuildResultBody(Preview);
+		Preview->SetBoolField(TEXT("dryRun"), true);
+		Preview->SetBoolField(TEXT("written"), false);
+		Preview->SetStringField(TEXT("wouldWrite"), OutputPath);
+		return MCPResult(Preview);
+	}
+
+	// ── Write ───────────────────────────────────────────────────────────────
+	UStaticMesh* Written = nullptr;
+	bool bCreatedAsset = false;
+
+	if (ExistingOutput)
+	{
+		FMeshBooleanCall CopyOut;
+		if (!CopyOut.Bind(GSStaticMeshFunctions, TEXT("CopyMeshToStaticMesh"), BindError))
+		{
+			return GeometryScriptingUnavailableError(BindError);
+		}
+		CopyOut.SetObject(TEXT("FromDynamicMesh"), TargetDynamic);
+		CopyOut.SetObject(TEXT("ToStaticMeshAsset"), ExistingOutput);
+		CopyOut.SetStructBool(TEXT("Options"), TEXT("bEnableRecomputeNormals"), bRecomputeNormals);
+		CopyOut.SetStructBool(TEXT("Options"), TEXT("bEnableRecomputeTangents"), bRecomputeTangents);
+		CopyOut.SetStructBool(TEXT("Options"), TEXT("bEnableRemoveDegenerates"), bRemoveDegenerates);
+		CopyOut.SetStructNumber(TEXT("TargetLOD"), TEXT("LODIndex"), 0);
+		CopyOut.SetBool(TEXT("bUseSectionMaterials"), true);
+		CopyOut.SetObject(TEXT("Debug"), Debug);
+		CopyOut.Invoke();
+		Messages.Append(DrainDebugMessages(Debug));
+
+		if (CopyOut.GetEnumName(TEXT("Outcome")) != TEXT("Success"))
+		{
+			TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+			Obj->SetBoolField(TEXT("success"), false);
+			Obj->SetStringField(TEXT("error"), FString::Printf(
+				TEXT("The boolean produced %d triangles but writing them into '%s' failed."),
+				ResultTriangles, *OutputPath));
+			Obj->SetStringField(TEXT("reason"), TEXT("write_failed"));
+			BuildResultBody(Obj);
+			return MakeShared<FJsonValueObject>(Obj);
+		}
+		Written = ExistingOutput;
+	}
+	else
+	{
+		FMeshBooleanCall Create;
+		if (!Create.Bind(GSCreateAssetFunctions, TEXT("CreateNewStaticMeshAssetFromMesh"), BindError))
+		{
+			return GeometryScriptingUnavailableError(FString::Printf(
+				TEXT("%s Creating a new StaticMesh asset needs the editor half of the plugin ")
+					TEXT("(GeometryScriptingEditor)."),
+				*BindError));
+		}
+		Create.SetObject(TEXT("FromDynamicMesh"), TargetDynamic);
+		Create.SetString(TEXT("AssetPathAndName"), OutputPath);
+		Create.SetStructBool(TEXT("Options"), TEXT("bEnableRecomputeNormals"), bRecomputeNormals);
+		Create.SetStructBool(TEXT("Options"), TEXT("bEnableRecomputeTangents"), bRecomputeTangents);
+		Create.SetStructBool(TEXT("Options"), TEXT("bEnableCollision"), bCopyCollision);
+		Create.SetStructBool(TEXT("Options"), TEXT("bEnableNanite"),
+			NaniteMode == TEXT("enable")
+			|| (NaniteMode == TEXT("inherit") && TargetMesh->GetNaniteSettings().bEnabled));
+		Create.SetObject(TEXT("Debug"), Debug);
+		Create.Invoke();
+		Messages.Append(DrainDebugMessages(Debug));
+
+		Written = Cast<UStaticMesh>(Create.ReturnObject());
+		if (Create.GetEnumName(TEXT("Outcome")) != TEXT("Success") || !Written)
+		{
+			TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+			Obj->SetBoolField(TEXT("success"), false);
+			Obj->SetStringField(TEXT("error"), FString::Printf(
+				TEXT("The boolean produced %d triangles but the new StaticMesh asset at '%s' could not be ")
+					TEXT("created. The path may be invalid or already taken by another asset type."),
+				ResultTriangles, *OutputPath));
+			Obj->SetStringField(TEXT("reason"), TEXT("create_failed"));
+			BuildResultBody(Obj);
+			return MakeShared<FJsonValueObject>(Obj);
+		}
+		bCreatedAsset = true;
+	}
+
+	// ── Post-write fixups: materials, collision, Nanite ─────────────────────
+	bool bMaterialsCopied = false;
+	if (bCopyMaterials && Written != TargetMesh)
+	{
+		// The dynamic mesh carried section indices as material IDs, so the
+		// target's slot list maps straight back onto the result's sections.
+		Written->Modify();
+		Written->SetStaticMaterials(TargetMesh->GetStaticMaterials());
+		bMaterialsCopied = true;
+	}
+
+	bool bCollisionCopied = false;
+	if (bCopyCollision && Written != TargetMesh)
+	{
+		bCollisionCopied = CopySimpleCollision(TargetMesh, Written);
+	}
+
+	bool bNaniteChanged = false;
+	{
+		FMeshNaniteSettings Settings = Written->GetNaniteSettings();
+		const bool bWant =
+			NaniteMode == TEXT("enable") ? true :
+			NaniteMode == TEXT("disable") ? false :
+			TargetMesh->GetNaniteSettings().bEnabled;
+		if (Settings.bEnabled != bWant)
+		{
+			Settings.bEnabled = bWant;
+			Written->Modify();
+			Written->SetNaniteSettings(Settings);
+			bNaniteChanged = true;
+		}
+	}
+
+	if (bMaterialsCopied || bCollisionCopied || bNaniteChanged)
+	{
+		Written->PostEditChange();
+	}
+
+	// ── Persist ─────────────────────────────────────────────────────────────
+	auto Result = MCPSuccess();
+	BuildResultBody(Result);
+	if (bCreatedAsset)
+	{
+		MCPSetCreated(Result);
+	}
+	else
+	{
+		MCPSetUpdated(Result);
+	}
+	Result->SetBoolField(TEXT("written"), true);
+	Result->SetBoolField(TEXT("createdOutputAsset"), bCreatedAsset);
+	Result->SetBoolField(TEXT("materialsCopiedFromTarget"), bMaterialsCopied);
+	Result->SetBoolField(TEXT("collisionCopiedFromTarget"), bCollisionCopied);
+	Result->SetStringField(TEXT("nanite"), NaniteMode);
+	Result->SetBoolField(TEXT("naniteChanged"), bNaniteChanged);
+	WriteMeshStats(Result, TEXT("output"), Written);
+
+	if (bSave)
+	{
+		FString SaveReason;
+		const bool bSaved = SaveAssetPackageChecked(Written, SaveReason);
+		MCPNoteSaveOutcome(Result, OutputPath, bSaved, SaveReason);
+	}
+	else
+	{
+		// The caller asked for this, so it is not a failure. It is still said
+		// out loud, because geometry that only exists in memory is gone at the
+		// next editor start and reads as a write that silently did not take.
+		Written->MarkPackageDirty();
+		Result->SetBoolField(TEXT("saved"), false);
+		Result->SetStringField(TEXT("saveSkippedReason"),
+			TEXT("save=false was requested, so the new geometry is dirty in memory only and is lost when the ")
+				TEXT("editor closes. Call asset(save) for it, or repeat with save=true."));
+	}
+
+	if (bCreatedAsset)
+	{
+		// The inverse of "this call created an asset" is deleting it. An
+		// in-place or replacing write has no inverse and gets no descriptor,
+		// because a rollback record that cannot restore the prior geometry
+		// would be a promise this handler cannot keep.
+		MCPSetDeleteAssetRollback(Result, OutputPath);
+	}
+	return MCPResult(Result);
+}