347 lines
8.7 KiB
C++
347 lines
8.7 KiB
C++
#include "WingFetcher.h"
|
|
#include "WingServer.h"
|
|
#include "WingUtils.h"
|
|
#include "Engine/Blueprint.h"
|
|
#include "EdGraph/EdGraph.h"
|
|
#include "EdGraph/EdGraphNode.h"
|
|
#include "EdGraph/EdGraphPin.h"
|
|
#include "Engine/SimpleConstructionScript.h"
|
|
#include "Engine/SCS_Node.h"
|
|
#include "Engine/World.h"
|
|
#include "Materials/Material.h"
|
|
#include "MaterialGraph/MaterialGraph.h"
|
|
#include "MaterialGraph/MaterialGraphNode.h"
|
|
#include "IMaterialEditor.h"
|
|
#include "Engine/LevelScriptBlueprint.h"
|
|
#include "Subsystems/AssetEditorSubsystem.h"
|
|
|
|
WingFetcher::WalkFunc WingFetcher::GetWalker(const FString& Step)
|
|
{
|
|
if (Step.Equals(TEXT("graph"), ESearchCase::IgnoreCase)) return &WingFetcher::Graph;
|
|
if (Step.Equals(TEXT("node"), ESearchCase::IgnoreCase)) return &WingFetcher::Node;
|
|
if (Step.Equals(TEXT("pin"), ESearchCase::IgnoreCase)) return &WingFetcher::Pin;
|
|
if (Step.Equals(TEXT("component"), ESearchCase::IgnoreCase)) return &WingFetcher::Component;
|
|
if (Step.Equals(TEXT("levelblueprint"), ESearchCase::IgnoreCase)) return &WingFetcher::LevelBlueprint;
|
|
return nullptr;
|
|
}
|
|
|
|
void WingFetcher::SetObj(UObject* InObj)
|
|
{
|
|
UWingServer::AddTouchedObject(InObj);
|
|
Obj = InObj;
|
|
ResultPin = nullptr;
|
|
}
|
|
|
|
void WingFetcher::SetPin(UEdGraphPin* InPin)
|
|
{
|
|
ResultPin = InPin;
|
|
Obj = nullptr;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::SetError()
|
|
{
|
|
bError = true;
|
|
Obj = nullptr;
|
|
ResultPin = nullptr;
|
|
OriginalAsset = nullptr;
|
|
Editor = nullptr;
|
|
return *this;
|
|
}
|
|
|
|
void WingFetcher::PathFailed(const TCHAR* Expected)
|
|
{
|
|
SetError();
|
|
if (ResultPin)
|
|
UWingServer::Printf(TEXT("ERROR: Path specifies a pin, but expected %s\n"), Expected);
|
|
else if (Obj)
|
|
UWingServer::Printf(TEXT("ERROR: Path specifies a %s, but expected %s\n"), *Obj->GetClass()->GetName(), Expected);
|
|
else
|
|
UWingServer::Printf(TEXT("ERROR: Path led to a null pointer\n"));
|
|
}
|
|
|
|
WingFetcher& WingFetcher::TypeMismatch(const TCHAR* Walker, const TCHAR* Expected)
|
|
{
|
|
SetError();
|
|
if (ResultPin)
|
|
UWingServer::Printf(TEXT("ERROR: Input to '%s' is a pin, but expected %s\n"), Walker, Expected);
|
|
else if (Obj)
|
|
UWingServer::Printf(TEXT("ERROR: Input to '%s' is %s, but expected %s\n"), Walker, *Obj->GetClass()->GetName(), Expected);
|
|
else
|
|
UWingServer::Printf(TEXT("ERROR: Path led to a null pointer\n"));
|
|
return *this;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Walk(const FString& Path)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
TArray<FString> Segments;
|
|
Path.ParseIntoArray(Segments, TEXT(","));
|
|
if (Segments.Num() == 0)
|
|
{
|
|
UWingServer::Print(TEXT("ERROR: Empty path\n"));
|
|
return SetError();
|
|
}
|
|
|
|
for (int32 i = 0; i < Segments.Num(); i++)
|
|
{
|
|
if (!Obj && !ResultPin)
|
|
{
|
|
Asset(Segments[i]);
|
|
if (bError) return *this;
|
|
continue;
|
|
}
|
|
|
|
FString Key, Value;
|
|
if (!Segments[i].Split(TEXT(":"), &Key, &Value))
|
|
Key = Segments[i];
|
|
|
|
WalkFunc Func = GetWalker(Key);
|
|
if (!Func)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Unknown path step '%s'\n"), *Key);
|
|
return SetError();
|
|
}
|
|
(this->*Func)(Value);
|
|
if (bError) return *this;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Asset(const FString& PackagePath)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
SetObj(LoadObject<UObject>(nullptr, *PackagePath));
|
|
if (!Obj)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Could not load asset '%s'\n"), *PackagePath);
|
|
return SetError();
|
|
}
|
|
|
|
OriginalAsset = Obj;
|
|
|
|
// Open the editor for this asset (or bring it to front if already open).
|
|
UAssetEditorSubsystem* Sub = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
|
|
if (!Sub || !Sub->OpenEditorForAsset(Obj))
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Could not open editor for '%s'\n"), *PackagePath);
|
|
return SetError();
|
|
}
|
|
Editor = Sub->FindEditorForAsset(OriginalAsset, false);
|
|
if (!Editor)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Could not find editor instance for '%s'\n"), *PackagePath);
|
|
return SetError();
|
|
}
|
|
|
|
// If this is a material, use the editor's transient copy.
|
|
if (UMaterial* Mat = ::Cast<UMaterial>(Obj))
|
|
{
|
|
IMaterialEditor *MatEditor = static_cast<IMaterialEditor*>(Editor);
|
|
SetObj(MatEditor->GetMaterialInterface()->GetBaseMaterial());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool WingFetcher::CheckAssetIsA(UClass* StaticClass)
|
|
{
|
|
if (bError) return false;
|
|
if (!OriginalAsset || !OriginalAsset->IsA(StaticClass))
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Asset is %s, expected %s\n"),
|
|
OriginalAsset ? *OriginalAsset->GetClass()->GetName() : TEXT("null"),
|
|
*StaticClass->GetName());
|
|
SetError();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Graph(const FString& Value)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
// Material with blank graph name → navigate to the material graph.
|
|
if (UMaterial* Mat = ::Cast<UMaterial>(Obj))
|
|
{
|
|
if (!Value.IsEmpty())
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Materials do not have named graphs (got '%s')\n"), *Value);
|
|
return SetError();
|
|
}
|
|
WingUtils::EnsureMaterialGraph(Mat);
|
|
if (!Mat->MaterialGraph)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Material '%s' has no material graph\n"), *Mat->GetName());
|
|
return SetError();
|
|
}
|
|
SetObj(Mat->MaterialGraph);
|
|
return *this;
|
|
}
|
|
|
|
UBlueprint* BP = ::Cast<UBlueprint>(Obj);
|
|
if (!BP)
|
|
return TypeMismatch(TEXT("graph"), TEXT("Blueprint or Material"));
|
|
|
|
TArray<UEdGraph*> Matches = WingUtils::AllGraphsNamed(BP, Value);
|
|
if (Matches.Num() == 0)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Graph '%s' not found in %s\n"), *Value, *BP->GetName());
|
|
return SetError();
|
|
}
|
|
if (Matches.Num() > 1)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Ambiguous graph '%s' in %s — %d matches\n"), *Value, *BP->GetName(), Matches.Num());
|
|
return SetError();
|
|
}
|
|
|
|
SetObj(Matches[0]);
|
|
return *this;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Node(const FString& Value)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
// If current object is a graph, search that graph
|
|
if (UEdGraph* G = ::Cast<UEdGraph>(Obj))
|
|
{
|
|
UEdGraphNode* Found = nullptr;
|
|
for (UEdGraphNode* N : G->Nodes)
|
|
{
|
|
if (!N || !WingUtils::Identifies(Value, N))
|
|
continue;
|
|
if (Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Ambiguous node '%s' in graph %s\n"), *Value, *G->GetName());
|
|
return SetError();
|
|
}
|
|
Found = N;
|
|
}
|
|
if (!Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Node '%s' not found in graph %s\n"), *Value, *G->GetName());
|
|
return SetError();
|
|
}
|
|
SetObj(Found);
|
|
return *this;
|
|
}
|
|
|
|
// If current object is a blueprint, search all graphs
|
|
if (UBlueprint* BP = ::Cast<UBlueprint>(Obj))
|
|
{
|
|
UEdGraphNode* Found = nullptr;
|
|
for (UEdGraph* G : WingUtils::AllGraphs(BP))
|
|
{
|
|
for (UEdGraphNode* N : G->Nodes)
|
|
{
|
|
if (!N || !WingUtils::Identifies(Value, N))
|
|
continue;
|
|
if (Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Ambiguous node '%s' in %s\n"), *Value, *BP->GetName());
|
|
return SetError();
|
|
}
|
|
Found = N;
|
|
}
|
|
}
|
|
if (!Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Node '%s' not found in %s\n"), *Value, *BP->GetName());
|
|
return SetError();
|
|
}
|
|
SetObj(Found);
|
|
return *this;
|
|
}
|
|
|
|
return TypeMismatch(TEXT("node"), TEXT("graph or Blueprint"));
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Pin(const FString& Value)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
UEdGraphNode* N = ::Cast<UEdGraphNode>(Obj);
|
|
if (!N)
|
|
return TypeMismatch(TEXT("pin"), TEXT("node"));
|
|
UEdGraphPin* Found = nullptr;
|
|
for (UEdGraphPin *P : N->Pins)
|
|
{
|
|
if (!WingUtils::Identifies(Value, P))
|
|
continue;
|
|
if (Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Ambiguous pin '%s' on node %s\n"),
|
|
*Value, *WingUtils::FormatName(N));
|
|
return SetError();
|
|
}
|
|
Found = P;
|
|
}
|
|
if (!Found)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Pin '%s' not found on node %s\n"),
|
|
*Value, *WingUtils::FormatName(N));
|
|
return SetError();
|
|
}
|
|
|
|
SetPin(Found);
|
|
return *this;
|
|
}
|
|
|
|
WingFetcher& WingFetcher::Component(const FString& Value)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
UBlueprint* BP = ::Cast<UBlueprint>(Obj);
|
|
if (!BP)
|
|
return TypeMismatch(TEXT("component"), TEXT("Blueprint"));
|
|
|
|
USimpleConstructionScript* SCS = BP->SimpleConstructionScript;
|
|
if (!SCS)
|
|
{
|
|
UWingServer::Printf(TEXT("ERROR: Blueprint %s has no SimpleConstructionScript (not an Actor Blueprint)\n"), *BP->GetName());
|
|
return SetError();
|
|
}
|
|
|
|
FName SearchName(*Value);
|
|
for (USCS_Node* SCSNode : SCS->GetAllNodes())
|
|
{
|
|
if (SCSNode && SCSNode->GetVariableName() == SearchName)
|
|
{
|
|
SetObj(SCSNode->ComponentTemplate);
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
UWingServer::Printf(TEXT("ERROR: Component '%s' not found in %s\n"), *Value, *BP->GetName());
|
|
return SetError();
|
|
}
|
|
|
|
WingFetcher& WingFetcher::LevelBlueprint(const FString& Value)
|
|
{
|
|
if (bError) return *this;
|
|
|
|
UWorld* World = ::Cast<UWorld>(Obj);
|
|
if (!World)
|
|
return TypeMismatch(TEXT("levelblueprint"), TEXT("World"));
|
|
|
|
if (!World->PersistentLevel)
|
|
{
|
|
UWingServer::Print(TEXT("ERROR: World has no PersistentLevel\n"));
|
|
return SetError();
|
|
}
|
|
|
|
ULevelScriptBlueprint* LevelBP = World->PersistentLevel->GetLevelScriptBlueprint(true);
|
|
if (!LevelBP)
|
|
{
|
|
UWingServer::Print(TEXT("ERROR: World has no level blueprint\n"));
|
|
return SetError();
|
|
}
|
|
|
|
SetObj(LevelBP);
|
|
return *this;
|
|
}
|
|
|