talezero/integration
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented new functions FindOneWithExternalID, etc.

Browse Source
This commit is contained in:
jyelon
2026-03-28 23:47:05 -04:00
parent 9790fa34e1
commit 2ad86bac1d
2 changed files with 123 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
Plugins/UEWingman/Source/UEWingman/Private/WingUtils.cpp
View File

@@ -65,10 +65,15 @@ FString WingUtils::ExternalizeID(FName Name)
return WingTokenizer::ExternalizeID(Name.ToString());
}
FName WingUtils::CheckInternalizeID(const FString &ExternalID)
{
return FName(WingTokenizer::CheckInternalizeID(ExternalID));
}
FString WingUtils::CheckProposedName(const FString &ExternalID)
{
FString InternalID = WingTokenizer::CheckInternalizeID(ExternalID);
if (!InternalID.IsEmpty() && WingTokenizer::WouldExternalizeReadably(InternalID))
if (!InternalID.IsEmpty() && !WingTokenizer::WouldExternalizeReadably(InternalID))
{
UWingServer::Printf(TEXT("ERROR: id %s would not be a readable id, may not create item with this name"),
*ExternalID);
@@ -351,6 +356,11 @@ bool WingUtils::CheckExactlyOneNamed(int Count, const TCHAR *Kind, const FString
return true;
}
bool WingUtils::CheckExactlyOneNamed(int Count, const TCHAR *Kind, FName Name)
{
return CheckExactlyOneNamed(Count, Kind, ExternalizeID(Name));
}
bool WingUtils::CheckExactlyNoneNamed(int Count, const TCHAR *Kind, const FString &Name)
{
if (Count > 0)
@@ -361,6 +371,11 @@ bool WingUtils::CheckExactlyNoneNamed(int Count, const TCHAR *Kind, const FStrin
return true;
}
bool WingUtils::CheckExactlyNoneNamed(int Count, const TCHAR *Kind, FName Name)
{
return CheckExactlyNoneNamed(Count, Kind, ExternalizeID(Name));
}
bool WingUtils::CheckCanRename(UEdGraphNode* Node, const FString &Name)
{
if (!Node->bCanRenameNode)

145
Plugins/UEWingman/Source/UEWingman/Public/WingUtils.h
View File

@@ -5,42 +5,122 @@
#include "EdGraph/EdGraph.h"
#include "EdGraph/EdGraphPin.h"
#include "Materials/MaterialInstanceConstant.h"
#include "Materials/MaterialExpression.h"
#include "MaterialTypes.h"
#include "Components/ActorComponent.h"
#include "Engine/SCS_Node.h"
#include "Engine/MemberReference.h"
#include "Engine/Blueprint.h"
#include "K2Node_EditablePinBase.h"
#include "Components/Widget.h"
#include "WingActorComponent.h"
class UBlueprint;
class UEdGraphNode;
class UEdGraphPin;
class UMaterial;
class UMaterialInstance;
class UMaterialFunction;
class UMaterialExpression;
struct FEdGraphSchemaAction;
class UAnimationStateMachineGraph;
class UAnimStateNode;
class UAnimStateTransitionNode;
class UActorComponent;
class UWorld;
class UStaticMesh;
class USkeletalMesh;
class UAnimSequence;
class UBlendSpace;
class UTexture;
class UScriptStruct;
class UEnum;
class USCS_Node;
class UWidget;
struct FMemberReference;
struct FBPVariableDescription;
struct FUserPinInfo;
struct FBPInterfaceDescription;
struct FWingActorComponent;
class UWingComponentReference;
#include "Engine/World.h"
#include "Materials/Material.h"
#include "Engine/StaticMesh.h"
#include "Engine/SkeletalMesh.h"
#include "Animation/AnimSequence.h"
#include "Animation/BlendSpace.h"
#include "Engine/Texture.h"
#include "Materials/MaterialFunction.h"
// Stateless utility functions used by MCP handlers and the MCP server.
// This is effectively a namespace — all methods are static.
class WingUtils
{
public:
// Given an array and a reference to an element of the array, return
// a pointer to the element, or if the element is already a pointer, the element.
template<class T> static const T* EltAsPtr(const TArray<T> &A, const T &Elt) { return &Elt; }
template<class T> static T* EltAsPtr(TArray<T> &A, T &Elt) { return &Elt; }
template<class T> static T* EltAsPtr(const TArray<T*> &A, T* &Elt) { return Elt; }
template<class T> static T* EltAsPtr(TArray<T*> &A, T* &Elt) { return Elt; }
template<class T> static const T* EltAsPtr(const TArray<const T*> &A, const T* &Elt) { return Elt; }
template<class T> static const T* EltAsPtr(TArray<const T*> &A, const T* &Elt) { return Elt; }
////////////////////////////////////////////////////////
//
// GetFName
//
// For objects whose FormatName uses ExternalizeID,
// GetFName returns the raw internal FName.
//
////////////////////////////////////////////////////////
static FName GetFName(const UActorComponent *C) { return C->GetFName(); }
static FName GetFName(const UEdGraph *Graph) { return Graph->GetFName(); }
static FName GetFName(const TObjectPtr<UEdGraph> &Graph) { return Graph->GetFName(); }
static FName GetFName(const UEdGraphNode* Node) { return Node->GetFName(); }
static FName GetFName(const UEdGraphPin *Pin) { return Pin->GetFName(); }
static FName GetFName(const FMemberReference &Ref) { return Ref.GetMemberName(); }
static FName GetFName(const FBPVariableDescription &Var) { return Var.VarName; }
static FName GetFName(const UMaterialExpression *Expression) { return Expression->GetFName(); }
static FName GetFName(const FProperty *Prop) { return Prop->GetFName(); }
static FName GetFName(const FUserPinInfo &Pin) { return Pin.PinName; }
static FName GetFName(const UWingComponentReference *Ref) { return Ref->VariableName; }
static FName GetFName(const UWidget *Widget) { return Widget->GetFName(); }
template<typename ArrayType>
static auto FindOneWithInternalID(FName InternalID, ArrayType &Array, const TCHAR *Kind)
{
decltype(EltAsPtr(Array, Array[0])) Result = nullptr;
int Count = 0;
for (auto &Elt : Array) if (GetFName(Elt) == InternalID) { Count++; Result = EltAsPtr(Array, Elt); }
if (!CheckExactlyOneNamed(Count, Kind, InternalID)) Result = nullptr;
return Result;
}
template<typename ArrayType>
static auto FindOneWithExternalID(const FString &ExternalID, ArrayType &Array, const TCHAR *Kind)
{
decltype(EltAsPtr(Array, Array[0])) Result = nullptr;
FName InternalID = CheckInternalizeID(ExternalID);
if (!InternalID.IsNone()) Result = FindOneWithInternalID(InternalID, Array, Kind);
return Result;
}
template<typename ArrayType>
static bool FindNoneWithInternalID(FName InternalID, ArrayType &Array, const TCHAR *Kind)
{
for (auto &Elt : Array) if (GetFName(Elt) == InternalID)
return CheckExactlyNoneNamed(1, Kind, InternalID);
return true;
}
template<typename ArrayType>
static bool FindNoneWithExternalID(const FString &ExternalID, ArrayType &Array, const TCHAR *Kind)
{
FName InternalID = CheckInternalizeID(ExternalID);
if (InternalID.IsNone()) return false;
return FindNoneWithInternalID(InternalID, Array, Kind);
}
////////////////////////////////////////////////////////
//
// GetPathName
//
// For objects whose FormatName returns a path name,
// GetPathName returns the raw path.
//
////////////////////////////////////////////////////////
static FString GetPathName(const UWorld *World) { return World->GetPathName(); }
static FString GetPathName(const UMaterial *Material) { return Material->GetPathName(); }
static FString GetPathName(const UMaterialInstance *MI) { return MI->GetPathName(); }
static FString GetPathName(const UMaterialFunction *MF) { return MF->GetPathName(); }
static FString GetPathName(const UStaticMesh *Mesh) { return Mesh->GetPathName(); }
static FString GetPathName(const USkeletalMesh *Mesh) { return Mesh->GetPathName(); }
static FString GetPathName(const UAnimSequence *Anim) { return Anim->GetPathName(); }
static FString GetPathName(const UTexture *Texture) { return Texture->GetPathName(); }
////////////////////////////////////////////////////////
//
// Name Formatting
@@ -78,7 +158,6 @@ public:
static FString FormatName(const FProperty *Prop);
static FString FormatName(const FUserPinInfo &Pin);
static FString FormatName(const FBPInterfaceDescription &IFace);
static FString FormatName(const FWingActorComponent &Comp);
static FString FormatName(const UWingComponentReference *Ref);
static FString FormatName(const UWidget *Widget);
@@ -97,21 +176,6 @@ public:
////////////////////////////////////////////////////////
template<typename T>
static TArray<T*> FindAllNamed(const FString &Name, const TArray<T*> &Array)
{
TArray<T*> Result;
for (T* Elt : Array) if (Identifies(Name, Elt)) Result.Add(Elt);
return Result;
}
template<typename T, typename = std::enable_if_t<!std::is_pointer_v<T>>>
static TArray<T*> FindAllNamed(const FString &Name, TArray<T> &Array)
{
TArray<T*> Result;
for (T& Elt : Array) if (Identifies(Name, Elt)) Result.Add(&Elt);
return Result;
}
template<typename T>
static T* FindExactlyOneNamed(const FString &Name, const TArray<T*> &Array, const TCHAR *Kind)
@@ -144,9 +208,11 @@ public:
}
////////////////////////////////////////////////////////
static FString ExternalizeID(const FString& Name);
static FString ExternalizeID(const FString& InternalID);
static FString ExternalizeID(FName Name);
static FName CheckInternalizeID(const FString &ExternalID);
////////////////////////////////////////////////////////
// In Unreal, Menu items tend to be an unpredictable
// mix of CamelCase without spaces, and with spaces.
@@ -218,7 +284,10 @@ public:
// ----- Common Error Reporting -----
static bool CheckExactlyOneNamed(int Count, const TCHAR *Kind, const FString &Name);
static bool CheckExactlyOneNamed(int Count, const TCHAR *Kind, FName Name);
static bool CheckExactlyNoneNamed(int Count, const TCHAR *Kind, const FString &Name);
static bool CheckExactlyNoneNamed(int Count, const TCHAR *Kind, FName Name);
static bool CheckCanRename(UEdGraphNode* Node, const FString &Name);
};