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

More work on blueprint exporter, and some work on build system

Browse Source
This commit is contained in:
jyelon
2026-02-16 17:24:52 -05:00
parent a0c8935260
commit 15997aee62
9 changed files with 345 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

404
Source/Integration/BlueprintExporter.cpp
View File

@@ -1,6 +1,7 @@
#if WITH_EDITOR
#include "BlueprintExporter.h"
#include "Common.h"
#include "Engine/Blueprint.h"
#include "EdGraph/EdGraph.h"
#include "EdGraph/EdGraphNode.h"
@@ -20,123 +21,35 @@ FlxBlueprintExporter::FlxBlueprintExporter(UEdGraph* InGraph)
EmitGraph();
}
void FlxBlueprintExporter::AssignNodeNames()
{
TMap<FString, int32> NextIndex;
////////////////////////////////////////////////////////
//
// General utilities for manipulating UEdGraph nodes.
//
////////////////////////////////////////////////////////
for (UEdGraphNode* Node : SortedNodes)
{
FString Base = SanitizeName(Node->GetNodeTitle(ENodeTitleType::ListView).ToString());
int32& Idx = NextIndex.FindOrAdd(Base, 0);
FString Name = (Idx == 0) ? Base : FString::Printf(TEXT("%s_%d"), *Base, Idx + 1);
NodeNames.Add(Node, Name);
Idx++;
}
FString FlxBlueprintExporter::SanitizeName(const FString& Title)
{
FString Result = Title.TrimStartAndEnd().Replace(TEXT(" "), TEXT("_"));
return Result.IsEmpty() ? TEXT("_") : Result;
}
void FlxBlueprintExporter::Traverse(UEdGraphNode* Node)
FString FlxBlueprintExporter::FormatPinType(UEdGraphPin* Pin)
{
if (Visited.Contains(Node)) return;
Visited.Add(Node);
// First, traverse input nodes
for (UEdGraphPin* Pin : Node->Pins)
if (UObject* SubObj = Pin->PinType.PinSubCategoryObject.Get())
{
if (Pin->Direction != EGPD_Input) continue;
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
{
Traverse(LinkedPin->GetOwningNode());
}
}
// Add this node to the sorted list.
SortedNodes.Add(Node);
// Then, traverse exec output nodes only.
// Data outputs are not followed — data nodes get pulled in
// through their consumers' input traversal.
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->Direction != EGPD_Output) continue;
if (Pin->PinType.PinCategory != UEdGraphSchema_K2::PC_Exec) continue;
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
{
Traverse(LinkedPin->GetOwningNode());
}
return SubObj->GetName();
}
FString Type = Pin->PinType.PinCategory.ToString();
Type[0] = FChar::ToUpper(Type[0]);
return Type;
}
bool FlxBlueprintExporter::HasExecPin(UEdGraphNode* Node, EEdGraphPinDirection Direction)
FString FlxBlueprintExporter::FormatNodeBaseName(UEdGraphNode* Node)
{
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec)
{
if (Pin->Direction == Direction) return true;
}
}
return false;
return SanitizeName(Node->GetNodeTitle(ENodeTitleType::ListView).ToString());
}
void FlxBlueprintExporter::SortNodes()
{
// Find starter nodes: have exec output but no exec input.
TArray<UEdGraphNode*> Starters;
for (UEdGraphNode* Node : Graph->Nodes)
{
if (HasExecPin(Node, EGPD_Output) && !HasExecPin(Node, EGPD_Input))
{
Starters.Add(Node);
}
}
// Sort starters by Y position.
Starters.Sort([](const UEdGraphNode& A, const UEdGraphNode& B)
{
return A.NodePosY < B.NodePosY;
});
// Traverse from each starter.
for (UEdGraphNode* Starter : Starters)
{
Traverse(Starter);
}
// Traverse all nodes.
for (UEdGraphNode* Node : Graph->Nodes)
{
Traverse(Node);
}
}
void FlxBlueprintExporter::EmitNodeList()
{
Output.Appendf(TEXT("NodeList:\n"));
for (UEdGraphNode* Node : SortedNodes)
{
if (Node->IsA<UK2Node_Knot>()) continue;
if (Node->IsA<UEdGraphNode_Comment>()) continue;
if (Node->IsA<UK2Node_VariableGet>()) continue;
Output.Appendf(TEXT(" %s = %s\n"),
*NodeNames[Node], *Node->NodeGuid.ToString());
}
}
FString FlxBlueprintExporter::GetPinDisplayName(UEdGraphPin *Pin)
{
FString Result = Pin->GetOwningNode()->GetPinDisplayName(Pin).ToString();
if (!Result.IsEmpty()) return Result;
return Pin->PinName.ToString();
}
UEdGraphPin* FlxBlueprintExporter::FindFirstPin(UEdGraphNode* Node, EEdGraphPinDirection Direction)
{
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->Direction == Direction) return Pin;
}
return nullptr;
}
UEdGraphPin* FlxBlueprintExporter::GetLinkedTo(UEdGraphPin* Pin)
{
@@ -150,15 +63,116 @@ UEdGraphPin* FlxBlueprintExporter::GetLinkedTo(UEdGraphPin* Pin)
}
}
FString FlxBlueprintExporter::FormatPinType(UEdGraphPin* Pin)
bool FlxBlueprintExporter::IsDefaultToSelf(UEdGraphPin* Pin)
{
if (UObject* SubObj = Pin->PinType.PinSubCategoryObject.Get())
// Only valid call-function nodes can have default-to-self.
UK2Node_CallFunction* CallNode = Cast<UK2Node_CallFunction>(Pin->GetOwningNode());
if (!CallNode) return false;
UFunction* Function = CallNode->GetTargetFunction();
if (!Function) return false;
// In a call function node, the pin name 'self' is reserved
// for the C++ 'this' pointer. This always has 'DefaultToSelf'
// behavior. Note that 'self' in other nodes is not special.
if (Pin->PinName == UEdGraphSchema_K2::PN_Self) return true;
// For any other pin name, we have to check for
// the presence of meta = (DefaultToSelf = "Pin")
const FString& DefaultToSelfPinName = Function->GetMetaData(FBlueprintMetadata::MD_DefaultToSelf);
return Pin->PinName.ToString() == DefaultToSelfPinName;
}
TArray<UEdGraphPin*> FlxBlueprintExporter::FilterPins(UEdGraphNode* Node, EEdGraphPinDirection Direction, FName Category)
{
TArray<UEdGraphPin*> Result;
for (UEdGraphPin* Pin : Node->Pins)
{
return SubObj->GetName();
if (Direction != EGPD_MAX && Pin->Direction != Direction) continue;
if (!Category.IsNone() && Pin->PinType.PinCategory != Category) continue;
Result.Add(Pin);
}
FString Type = Pin->PinType.PinCategory.ToString();
Type[0] = FChar::ToUpper(Type[0]);
return Type;
return Result;
}
bool FlxBlueprintExporter::HasExecPin(UEdGraphNode* Node, EEdGraphPinDirection Direction)
{
return FilterPins(Node, Direction, UEdGraphSchema_K2::PC_Exec).Num() > 0;
}
UEdGraphPin* FlxBlueprintExporter::FindFirstPin(UEdGraphNode* Node, EEdGraphPinDirection Direction)
{
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->Direction == Direction) return Pin;
}
return nullptr;
}
UEdGraphPin* FlxBlueprintExporter::BestMatchPin(UEdGraphNode* Node, EEdGraphPinDirection Direction, bool Exec, const FString& Name)
{
if (Name == TEXT("_")) return nullptr;
UEdGraphPin* DisplayMatch = nullptr;
int32 DisplayCount = 0;
UEdGraphPin* RawMatch = nullptr;
int32 RawCount = 0;
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->Direction != Direction) continue;
bool PinIsExec = (Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec);
if (PinIsExec != Exec) continue;
if (Name == SanitizeName(Node->GetPinDisplayName(Pin).ToString()))
{
DisplayMatch = Pin;
DisplayCount++;
}
if (Name == SanitizeName(Pin->PinName.ToString()))
{
RawMatch = Pin;
RawCount++;
}
}
if (DisplayCount == 1) return DisplayMatch;
if (RawCount == 1) return RawMatch;
return nullptr;
}
FString FlxBlueprintExporter::FormatPinName(UEdGraphPin *Pin)
{
UEdGraphNode* Node = Pin->GetOwningNode();
bool Exec = (Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec);
// Try sanitized display name first.
FString SanitizedDisplay = SanitizeName(Node->GetPinDisplayName(Pin).ToString());
if (BestMatchPin(Node, Pin->Direction, Exec, SanitizedDisplay) == Pin)
return SanitizedDisplay;
// Try sanitized raw name.
FString SanitizedRaw = SanitizeName(Pin->PinName.ToString());
if (BestMatchPin(Node, Pin->Direction, Exec, SanitizedRaw) == Pin)
return SanitizedRaw;
// No unambiguous name found.
UE_LOG(LogLuprexIntegration, Warning, TEXT("Blueprint export: ambiguous pin name '%s' on node '%s'"),
*Pin->PinName.ToString(), *Node->GetNodeTitle(ENodeTitleType::ListView).ToString());
return FString::Printf(TEXT("?%s"), *SanitizedRaw);
}
////////////////////////////////////////////////////////
//
// Traverse and Emit the Nodes.
//
////////////////////////////////////////////////////////
FString FlxBlueprintExporter::FormatNodeName(UEdGraphNode* Node)
{
FString* Name = NodeNames.Find(Node);
return Name ? *Name : FormatNodeBaseName(Node);
}
FString FlxBlueprintExporter::FormatPinSource(UEdGraphPin* Pin)
@@ -173,9 +187,8 @@ FString FlxBlueprintExporter::FormatPinSource(UEdGraphPin* Pin)
if (UK2Node_VariableGet* VarGet = Cast<UK2Node_VariableGet>(LinkedToNode))
return SanitizeName(VarGet->GetVarNameString());
FString PinLabel = SanitizeName(GetPinDisplayName(LinkedTo));
FString* Name = NodeNames.Find(LinkedToNode);
return FString::Printf(TEXT("%s.%s"), **Name, *PinLabel);
FString PinLabel = FormatPinName(LinkedTo);
return FString::Printf(TEXT("%s.%s"), *FormatNodeName(LinkedToNode), *PinLabel);
}
// String pins: always show in quotes (even if empty).
@@ -213,131 +226,144 @@ FString FlxBlueprintExporter::FormatPinSource(UEdGraphPin* Pin)
}
}
void FlxBlueprintExporter::Traverse(UEdGraphNode* Node)
{
if (Visited.Contains(Node)) return;
Visited.Add(Node);
// First, traverse input nodes
for (UEdGraphPin* Pin : FilterPins(Node, EGPD_Input))
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
Traverse(LinkedPin->GetOwningNode());
// Add this node to the sorted list.
SortedNodes.Add(Node);
// Then, traverse exec output nodes only.
// Data outputs are not followed — data nodes get pulled in
// through their consumers' input traversal.
for (UEdGraphPin* Pin : FilterPins(Node, EGPD_Output, UEdGraphSchema_K2::PC_Exec))
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
Traverse(LinkedPin->GetOwningNode());
}
void FlxBlueprintExporter::SortNodes()
{
// Find starter nodes: have exec output but no exec input.
TArray<UEdGraphNode*> Starters;
for (UEdGraphNode* Node : Graph->Nodes)
{
if (HasExecPin(Node, EGPD_Output) && !HasExecPin(Node, EGPD_Input))
{
Starters.Add(Node);
}
}
// Sort starters by Y position.
Starters.Sort([](const UEdGraphNode& A, const UEdGraphNode& B)
{
return A.NodePosY < B.NodePosY;
});
// Traverse from each starter.
for (UEdGraphNode* Starter : Starters)
{
Traverse(Starter);
}
// Traverse all nodes.
for (UEdGraphNode* Node : Graph->Nodes)
{
Traverse(Node);
}
}
void FlxBlueprintExporter::AssignNodeNames()
{
TMap<FString, int32> NextIndex;
for (UEdGraphNode* Node : SortedNodes)
{
FString Base = FormatNodeBaseName(Node);
int32& Idx = NextIndex.FindOrAdd(Base, 0);
FString Name = (Idx == 0) ? Base : FString::Printf(TEXT("%s_%d"), *Base, Idx + 1);
NodeNames.Add(Node, Name);
Idx++;
}
}
void FlxBlueprintExporter::EmitNode(UEdGraphNode* Node)
{
if (Node->IsA<UEdGraphNode_Comment>())
{
Output.Appendf(TEXT("\n // %s\n"), *Node->NodeComment);
Output.Appendf(TEXT("\n// %s\n"), *Node->NodeComment);
return;
}
if (Node->IsA<UK2Node_VariableGet>())
return;
Output.Appendf(TEXT("\n %s\n"), *NodeNames[Node]);
Output.Appendf(TEXT("\nnode %s\n"), *FormatNodeName(Node));
// Emit input data pins.
for (UEdGraphPin* Pin : Node->Pins)
for (UEdGraphPin* Pin : FilterPins(Node, EGPD_Input))
{
if (Pin->Direction != EGPD_Input) continue;
if (Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec) continue;
if (Pin->bHidden) continue;
Output.Appendf(TEXT(" %s %s = %s\n"),
Output.Appendf(TEXT(" input %s %s = %s\n"),
*FormatPinType(Pin),
*SanitizeName(GetPinDisplayName(Pin)),
*FormatPinName(Pin),
*FormatPinSource(Pin));
}
// Emit output data pins as a return line.
FString ReturnPins;
for (UEdGraphPin* Pin : Node->Pins)
for (UEdGraphPin* Pin : FilterPins(Node, EGPD_Output))
{
if (Pin->Direction != EGPD_Output) continue;
if (Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec) continue;
if (Pin->bHidden) continue;
if (!ReturnPins.IsEmpty()) ReturnPins += TEXT(",");
ReturnPins += SanitizeName(GetPinDisplayName(Pin));
if (!ReturnPins.IsEmpty()) ReturnPins += TEXT(", ");
ReturnPins += FormatPinName(Pin);
}
if (!ReturnPins.IsEmpty())
Output.Appendf(TEXT(" return %s\n"), *ReturnPins);
// Detect output exec pin patterns.
int32 ExecOutCount = 0;
bool HasElsePin = false;
for (UEdGraphPin* Pin : Node->Pins)
{
if (Pin->Direction != EGPD_Output) continue;
if (Pin->PinType.PinCategory != UEdGraphSchema_K2::PC_Exec) continue;
ExecOutCount++;
if (Pin->PinName == TEXT("Else"))
HasElsePin = true;
Output.Appendf(TEXT(" return %s\n"), *ReturnPins);
}
// Emit output exec pins as goto statements.
for (UEdGraphPin* Pin : Node->Pins)
TArray<UEdGraphPin*> ExecOuts = FilterPins(Node, EGPD_Output, UEdGraphSchema_K2::PC_Exec);
for (UEdGraphPin* Pin : ExecOuts)
{
if (Pin->Direction != EGPD_Output) continue;
if (Pin->PinType.PinCategory != UEdGraphSchema_K2::PC_Exec) continue;
UEdGraphPin* LinkedTo = GetLinkedTo(Pin);
if (!LinkedTo) continue;
FString* TargetName = NodeNames.Find(LinkedTo->GetOwningNode());
FString Target = TargetName ? *TargetName : TEXT("?");
FString Target = FormatNodeName(LinkedTo->GetOwningNode());
if (ExecOutCount == 1)
if (ExecOuts.Num() == 1)
Output.Appendf(TEXT(" goto %s\n"), *Target);
else if (HasElsePin)
Output.Appendf(TEXT(" %s goto %s\n"), *Pin->PinName.ToString().ToLower(), *Target);
else
Output.Appendf(TEXT(" goto %s if %s\n"), *Target, *Pin->PinName.ToString());
Output.Appendf(TEXT(" goto-if %s %s\n"), *FormatPinName(Pin), *Target);
}
}
void FlxBlueprintExporter::EmitGraph()
{
Output.Appendf(TEXT("\nGraph:\n"));
for (UEdGraphNode* Node : SortedNodes)
{
if (Node->IsA<UK2Node_Knot>()) continue;
if (Node->IsA<UK2Node_VariableGet>()) continue;
EmitNode(Node);
}
}
bool FlxBlueprintExporter::IsDefaultToSelf(UEdGraphPin* Pin)
void FlxBlueprintExporter::EmitNodeList()
{
// The engine's own IsSelfPin check.
if (Pin->PinName == UEdGraphSchema_K2::PN_Self)
return true;
// Check if the owning node is a function call with DefaultToSelf metadata naming this pin.
UK2Node_CallFunction* CallNode = Cast<UK2Node_CallFunction>(Pin->GetOwningNode());
if (!CallNode) return false;
UFunction* Function = CallNode->GetTargetFunction();
if (!Function) return false;
const FString& DefaultToSelfPinName = Function->GetMetaData(FBlueprintMetadata::MD_DefaultToSelf);
return Pin->PinName.ToString() == DefaultToSelfPinName;
}
FString FlxBlueprintExporter::SanitizeName(const FString& Title)
{
FString Result;
bool PrevWasUnderscore = true; // suppress leading underscore
for (TCHAR Ch : Title)
for (UEdGraphNode* Node : SortedNodes)
{
if (FChar::IsWhitespace(Ch))
{
if (!PrevWasUnderscore)
{
Result += TEXT('_');
PrevWasUnderscore = true;
}
}
else
{
Result += Ch;
PrevWasUnderscore = false;
}
if (Node->IsA<UK2Node_Knot>()) continue;
if (Node->IsA<UEdGraphNode_Comment>()) continue;
if (Node->IsA<UK2Node_VariableGet>()) continue;
Details.Appendf(TEXT("%s = %s\n"),
*FormatNodeName(Node), *Node->NodeGuid.ToString());
}
// Trim trailing underscore
if (Result.Len() > 0 && Result[Result.Len() - 1] == TEXT('_'))
{
Result.LeftChopInline(1);
}
return Result.IsEmpty() ? TEXT("_") : Result;
}
#endif