void PurgeAllDelegates()
{
for (auto d : Delegates)
{
delete d;
}
Delegates.Empty();
}
uint32 FArchiveObjectCrc32::Crc32(UObject* Object, uint32 CRC)
{
#ifdef DEBUG_ARCHIVE_OBJECT_CRC32
const double StartTime = FPlatformTime::Seconds();
UE_LOG(LogArchiveObjectCrc32, Log, TEXT("### Calculating CRC for object: %s with outer: %s"), *Object->GetName(), Object->GetOuter() ? *Object->GetOuter()->GetName() : TEXT("NULL"));
#endif
RootObject = Object;
if (Object)
{
TSet<UObject*> SerializedObjects;
// Start with the given object
ObjectsToSerialize.Enqueue(Object);
// Continue until we no longer have any objects to serialized
while (ObjectsToSerialize.Dequeue(Object))
{
bool bAlreadyProcessed = false;
SerializedObjects.Add(Object, &bAlreadyProcessed);
// If we haven't already serialized this object
if (!bAlreadyProcessed)
{
#ifdef DEBUG_ARCHIVE_OBJECT_CRC32
UE_LOG(LogArchiveObjectCrc32, Log, TEXT("- Serializing object: %s with outer: %s"), *Object->GetName(), Object->GetOuter() ? *Object->GetOuter()->GetName() : TEXT("NULL"));
#endif
// Serialize it
ObjectBeingSerialized = Object;
if (!CustomSerialize(Object))
{
Object->Serialize(*this);
}
ObjectBeingSerialized = NULL;
// Calculate the CRC, compounding it with the checksum calculated from the previous object
CRC = FCrc::MemCrc32(SerializedObjectData.GetData(), SerializedObjectData.Num(), CRC);
#ifdef DEBUG_ARCHIVE_OBJECT_CRC32
UE_LOG(LogArchiveObjectCrc32, Log, TEXT("=> object: '%s', total size: %d bytes, checksum: 0x%08x"), *GetPathNameSafe(Object), SerializedObjectData.Num(), CRC);
#endif
// Cleanup
MemoryWriter.Seek(0L);
SerializedObjectData.Empty();
}
}
// Cleanup
SerializedObjects.Empty();
RootObject = NULL;
}
#ifdef DEBUG_ARCHIVE_OBJECT_CRC32
UE_LOG(LogArchiveObjectCrc32, Log, TEXT("### Finished (%.02f ms), final checksum: 0x%08x"), (FPlatformTime::Seconds() - StartTime) * 1000.0f, CRC);
#endif
return CRC;
}
/*Function which retrieves an arranged list of assets with the same nature (coresponding tags: Item, Stackable, ItemType)
which are placed on top of one another in the world (eg: a stack of plates)
The list is used for picking up multiple items at once in the GrabWithTwoHands() method.
@param AActor* ContainedItem --> Actor contained within the stack needed
*/
TSet<AActor*> AMyCharacter::GetStack(AActor* ContainedItem)
{
//Create an empty array to be populated with proper values
TSet<AActor*> StackList;
StackList.Empty();
//Make sure that the function parameter is logicaly valid and if not return an empty stack and exit the function call
if (!ContainedItem->ActorHasTag(FName(TEXT("Stackable"))))
{
return StackList;
}
/*Loop through the list of stackable items created in BeginPlay() and check for matching tags, as well as world positioning,
and populate the array with elements which are found to have the center on the same Z axis as the recieved parameter (+/- a small offset)
*/
for (const auto Iterator : AllStackableItems)
{
if (Iterator->Tags == ContainedItem->Tags)
{
if ((ContainedItem->GetActorLocation().X - 2 < Iterator->GetActorLocation().X) &&
(Iterator->GetActorLocation().X < ContainedItem->GetActorLocation().X + 2) &&
(ContainedItem->GetActorLocation().Y - 2 < Iterator->GetActorLocation().Y) &&
(Iterator->GetActorLocation().Y< ContainedItem->GetActorLocation().Y + 2))
{
StackList.Add(Iterator);
}
}
}
//Bubble sort algorithm
bool swapped = true;
int j = 0;
AActor* tmp;
while (swapped) {
swapped = false;
j++;
for (int i = 0; i < StackList.Num() - j; i++) {
if (StackList[FSetElementId::FromInteger(i)]->GetActorLocation().Z > StackList[FSetElementId::FromInteger(i + 1)]->GetActorLocation().Z)
{
tmp = StackList[FSetElementId::FromInteger(i)];
StackList[FSetElementId::FromInteger(i)] = StackList[FSetElementId::FromInteger(i + 1)];
StackList[FSetElementId::FromInteger(i + 1)] = tmp;
swapped = true;
}
}
}
return StackList;
}
/**
* Dissociates all linker import and forced export object references. This currently needs to
* happen as the referred objects might be destroyed at any time.
*/
void DissociateImportsAndForcedExports()
{
if( GImportCount && GObjLoadersWithNewImports.Num())
{
for (TSet< ULinkerLoad*>::TIterator It(GObjLoadersWithNewImports); It; ++It)
{
ULinkerLoad* Linker = *It;
for( int32 ImportIndex=0; ImportIndex<Linker->ImportMap.Num(); ImportIndex++ )
{
FObjectImport& Import = Linker->ImportMap[ImportIndex];
if( Import.XObject && !Import.XObject->HasAnyFlags(RF_Native) )
{
Import.XObject = NULL;
}
Import.SourceLinker = NULL;
// when the SourceLinker is reset, the SourceIndex must also be reset, or recreating
// an import that points to a redirector will fail to find the redirector
Import.SourceIndex = INDEX_NONE;
}
}
}
GImportCount = 0;
GObjLoadersWithNewImports.Empty();
if( GForcedExportCount )
{
for (TMap<UPackage*, ULinkerLoad*>::TIterator It(GObjLoaders); It; ++It)
{
ULinkerLoad* Linker = It.Value();
//@todo optimization: only dissociate exports for loaders that had forced exports created
//@todo optimization: since the last time this function was called.
for( int32 ExportIndex=0; ExportIndex<Linker->ExportMap.Num(); ExportIndex++ )
{
FObjectExport& Export = Linker->ExportMap[ExportIndex];
if( Export.Object && Export.bForcedExport )
{
Export.Object->SetLinker( NULL, INDEX_NONE );
Export.Object = NULL;
}
}
}
}
GForcedExportCount = 0;
}
void FGraphNodeClassHelper::UpdateAvailableBlueprintClasses()
{
if (FModuleManager::Get().IsModuleLoaded(TEXT("AssetRegistry")))
{
FAssetRegistryModule& AssetRegistryModule = FModuleManager::GetModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
const bool bSearchSubClasses = true;
TArray<FName> ClassNames;
TSet<FName> DerivedClassNames;
for (TMap<UClass*, int32>::TIterator It(BlueprintClassCount); It; ++It)
{
ClassNames.Reset();
ClassNames.Add(It.Key()->GetFName());
DerivedClassNames.Empty(DerivedClassNames.Num());
AssetRegistryModule.Get().GetDerivedClassNames(ClassNames, TSet<FName>(), DerivedClassNames);
int32& Count = It.Value();
Count = DerivedClassNames.Num();
}
}
}
FReply SGraphPin::OnPinMouseDown( const FGeometry& SenderGeometry, const FPointerEvent& MouseEvent )
{
bIsMovingLinks = false;
if (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
{
if (!GraphPinObj->bNotConnectable && IsEditable.Get())
{
if (MouseEvent.IsAltDown())
{
// Alt-Left clicking will break all existing connections to a pin
const UEdGraphSchema* Schema = GraphPinObj->GetSchema();
Schema->BreakPinLinks(*GraphPinObj, true);
return FReply::Handled();
}
auto OwnerNodePinned = OwnerNodePtr.Pin();
if (MouseEvent.IsControlDown() && (GraphPinObj->LinkedTo.Num() > 0))
{
// Get a reference to the owning panel widget
check(OwnerNodePinned.IsValid());
TSharedPtr<SGraphPanel> OwnerPanelPtr = OwnerNodePinned->GetOwnerPanel();
check(OwnerPanelPtr.IsValid());
// Obtain the set of all pins within the panel
TSet<TSharedRef<SWidget> > AllPins;
OwnerPanelPtr->GetAllPins(AllPins);
// Construct a UEdGraphPin->SGraphPin mapping for the full pin set
TMap< UEdGraphPin*, TSharedRef<SGraphPin> > PinToPinWidgetMap;
for( TSet< TSharedRef<SWidget> >::TIterator ConnectorIt(AllPins); ConnectorIt; ++ConnectorIt )
{
const TSharedRef<SWidget>& SomePinWidget = *ConnectorIt;
const SGraphPin& PinWidget = static_cast<const SGraphPin&>(SomePinWidget.Get());
PinToPinWidgetMap.Add(PinWidget.GetPinObj(), StaticCastSharedRef<SGraphPin>(SomePinWidget));
}
// Define a local struct to temporarily store lookup information for pins that we are currently linked to
struct LinkedToPinInfo
{
// Pin name string
FString PinName;
// A weak reference to the node object that owns the pin
TWeakObjectPtr<UEdGraphNode> OwnerNodePtr;
};
// Build a lookup table containing information about the set of pins that we're currently linked to
TArray<LinkedToPinInfo> LinkedToPinInfoArray;
for( TArray<UEdGraphPin*>::TIterator LinkArrayIter(GetPinObj()->LinkedTo); LinkArrayIter; ++LinkArrayIter )
{
if (auto PinWidget = PinToPinWidgetMap.Find(*LinkArrayIter))
{
check((*PinWidget)->OwnerNodePtr.IsValid());
LinkedToPinInfo PinInfo;
PinInfo.PinName = (*PinWidget)->GetPinObj()->PinName;
PinInfo.OwnerNodePtr = (*PinWidget)->OwnerNodePtr.Pin()->GetNodeObj();
LinkedToPinInfoArray.Add(PinInfo);
}
}
// Control-Left clicking will break all existing connections to a pin
// Note that for some nodes, this can cause reconstruction. In that case, pins we had previously linked to may now be destroyed.
const UEdGraphSchema* Schema = GraphPinObj->GetSchema();
Schema->BreakPinLinks(*GraphPinObj, true);
// Check to see if the panel has been invalidated by a graph change notification
if (!OwnerPanelPtr->Contains(OwnerNodePinned->GetNodeObj()))
{
// Force the panel to update. This will cause node & pin widgets to be reinstanced to match any reconstructed node/pin object references.
OwnerPanelPtr->Update();
// Obtain the full set of pins again after the update
AllPins.Empty(AllPins.Num());
OwnerPanelPtr->GetAllPins(AllPins);
// Rebuild the UEdGraphPin->SGraphPin mapping for the full pin set
PinToPinWidgetMap.Empty(PinToPinWidgetMap.Num());
for( TSet< TSharedRef<SWidget> >::TIterator ConnectorIt(AllPins); ConnectorIt; ++ConnectorIt )
{
const TSharedRef<SWidget>& SomePinWidget = *ConnectorIt;
const SGraphPin& PinWidget = static_cast<const SGraphPin&>(SomePinWidget.Get());
PinToPinWidgetMap.Add(PinWidget.GetPinObj(), StaticCastSharedRef<SGraphPin>(SomePinWidget));
}
}
// Now iterate over our lookup table to find the instances of pin widgets that we had previously linked to
TArray<TSharedRef<SGraphPin>> PinArray;
for(auto LinkedToPinInfoIter = LinkedToPinInfoArray.CreateConstIterator(); LinkedToPinInfoIter; ++LinkedToPinInfoIter)
{
LinkedToPinInfo PinInfo = *LinkedToPinInfoIter;
UEdGraphNode* OwnerNodeObj = PinInfo.OwnerNodePtr.Get();
if(OwnerNodeObj != NULL)
{
for(auto PinIter = PinInfo.OwnerNodePtr.Get()->Pins.CreateConstIterator(); PinIter; ++PinIter)
{
UEdGraphPin* Pin = *PinIter;
if(Pin->PinName == PinInfo.PinName)
{
if (auto pWidget = PinToPinWidgetMap.Find(Pin))
{
PinArray.Add(*pWidget);
}
}
}
}
}
if(PinArray.Num() > 0)
{
bIsMovingLinks = true;
return FReply::Handled().BeginDragDrop(SpawnPinDragEvent(OwnerPanelPtr.ToSharedRef(), PinArray, /*bIsShiftOperation=*/ false));
}
else
{
// Shouldn't get here, but just in case we lose our previous links somehow after breaking them, we'll just skip the drag.
return FReply::Handled();
}
}
// Start a drag-drop on the pin
if (ensure(OwnerNodePinned.IsValid()))
{
TArray<TSharedRef<SGraphPin>> PinArray;
PinArray.Add(SharedThis(this));
return FReply::Handled().BeginDragDrop(SpawnPinDragEvent(OwnerNodePinned->GetOwnerPanel().ToSharedRef(), PinArray, MouseEvent.IsShiftDown()));
}
else
{
return FReply::Unhandled();
}
}
else
{
// It's not connectable, but we don't want anything above us to process this left click.
return FReply::Handled();
}
}
else
{
return FReply::Unhandled();
}
}
/**
* Helper method designed to perform the necessary preparations required to complete an automated editor build
*
* @param BuildSettings Build settings that will be used for the editor build
* @param OutPkgsToSubmit Set of packages that need to be saved and submitted after a successful build
* @param OutErrorMessages Errors that resulted from the preparation (may or may not force the build to stop, depending on build settings)
*
* @return true if the preparation was successful and the build should continue; false if the preparation failed and the build should be aborted
*/
bool FEditorBuildUtils::PrepForAutomatedBuild( const FEditorAutomatedBuildSettings& BuildSettings, TSet<UPackage*>& OutPkgsToSubmit, FText& OutErrorMessages )
{
// Assume the preparation is successful to start
bool bBuildSuccessful = true;
OutPkgsToSubmit.Empty();
ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider();
// Source control is required for the automated build, so ensure that SCC support is compiled in and
// that the server is enabled and available for use
if ( !ISourceControlModule::Get().IsEnabled() || !SourceControlProvider.IsAvailable() )
{
bBuildSuccessful = false;
LogErrorMessage( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_SCCError", "Cannot connect to source control; automated build aborted."), OutErrorMessages );
}
// Empty changelists aren't allowed; abort the build if one wasn't provided
if ( bBuildSuccessful && BuildSettings.ChangeDescription.Len() == 0 )
{
bBuildSuccessful = false;
LogErrorMessage( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_NoCLDesc", "A changelist description must be provided; automated build aborted."), OutErrorMessages );
}
TArray<UPackage*> PreviouslySavedWorldPackages;
TArray<UPackage*> PackagesToCheckout;
TArray<ULevel*> LevelsToSave;
if ( bBuildSuccessful )
{
TArray<UWorld*> AllWorlds;
FString UnsavedWorlds;
EditorLevelUtils::GetWorlds( GWorld, AllWorlds, true );
// Check all of the worlds that will be built to ensure they have been saved before and have a filename
// associated with them. If they don't, they won't be able to be submitted to source control.
FString CurWorldPkgFileName;
for ( TArray<UWorld*>::TConstIterator WorldIter( AllWorlds ); WorldIter; ++WorldIter )
{
const UWorld* CurWorld = *WorldIter;
check( CurWorld );
UPackage* CurWorldPackage = CurWorld->GetOutermost();
check( CurWorldPackage );
if ( FPackageName::DoesPackageExist( CurWorldPackage->GetName(), NULL, &CurWorldPkgFileName ) )
{
PreviouslySavedWorldPackages.AddUnique( CurWorldPackage );
// Add all packages which have a corresponding file to the set of packages to submit for now. As preparation continues
// any packages that can't be submitted due to some error will be removed.
OutPkgsToSubmit.Add( CurWorldPackage );
}
else
{
UnsavedWorlds += FString::Printf( TEXT("%s\n"), *CurWorldPackage->GetName() );
}
}
// If any of the worlds haven't been saved before, process the build setting's behavior to see if the build
// should proceed or not
if ( UnsavedWorlds.Len() > 0 )
{
bBuildSuccessful = ProcessAutomatedBuildBehavior( BuildSettings.NewMapBehavior,
FText::Format( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_UnsavedMap", "The following levels have never been saved before and cannot be submitted:\n\n{0}\n\nAttempt to continue the build?"), FText::FromString(UnsavedWorlds) ),
OutErrorMessages );
}
}
// Load the asset tools module
FAssetToolsModule& AssetToolsModule = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools");
if ( bBuildSuccessful )
{
// Update the source control status of any relevant world packages in order to determine which need to be
// checked out, added to the depot, etc.
SourceControlProvider.Execute( ISourceControlOperation::Create<FUpdateStatus>(), SourceControlHelpers::PackageFilenames(PreviouslySavedWorldPackages) );
FString PkgsThatCantBeCheckedOut;
for ( TArray<UPackage*>::TConstIterator PkgIter( PreviouslySavedWorldPackages ); PkgIter; ++PkgIter )
{
UPackage* CurPackage = *PkgIter;
const FString CurPkgName = CurPackage->GetName();
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(CurPackage, EStateCacheUsage::ForceUpdate);
if( !SourceControlState.IsValid() ||
(!SourceControlState->IsSourceControlled() &&
!SourceControlState->IsUnknown() &&
!SourceControlState->IsIgnored()))
{
FString CurFilename;
if ( FPackageName::DoesPackageExist( CurPkgName, NULL, &CurFilename ) )
{
if ( IFileManager::Get().IsReadOnly( *CurFilename ) )
{
PkgsThatCantBeCheckedOut += FString::Printf( TEXT("%s\n"), *CurPkgName );
OutPkgsToSubmit.Remove( CurPackage );
}
}
}
else if(SourceControlState->CanCheckout())
{
PackagesToCheckout.Add( CurPackage );
}
else
{
PkgsThatCantBeCheckedOut += FString::Printf( TEXT("%s\n"), *CurPkgName );
OutPkgsToSubmit.Remove( CurPackage );
}
}
// If any of the packages can't be checked out or are read-only, process the build setting's behavior to see if the build
// should proceed or not
if ( PkgsThatCantBeCheckedOut.Len() > 0 )
{
bBuildSuccessful = ProcessAutomatedBuildBehavior( BuildSettings.UnableToCheckoutFilesBehavior,
FText::Format( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_UnsaveableFiles", "The following assets cannot be checked out of source control (or are read-only) and cannot be submitted:\n\n{0}\n\nAttempt to continue the build?"), FText::FromString(PkgsThatCantBeCheckedOut) ),
OutErrorMessages );
}
}
if ( bBuildSuccessful )
{
// Check out all of the packages from source control that need to be checked out
if ( PackagesToCheckout.Num() > 0 )
{
TArray<FString> PackageFilenames = SourceControlHelpers::PackageFilenames(PackagesToCheckout);
SourceControlProvider.Execute( ISourceControlOperation::Create<FCheckOut>(), PackageFilenames );
// Update the package status of the packages that were just checked out to confirm that they
// were actually checked out correctly
SourceControlProvider.Execute( ISourceControlOperation::Create<FUpdateStatus>(), PackageFilenames );
FString FilesThatFailedCheckout;
for ( TArray<UPackage*>::TConstIterator CheckedOutIter( PackagesToCheckout ); CheckedOutIter; ++CheckedOutIter )
{
UPackage* CurPkg = *CheckedOutIter;
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(CurPkg, EStateCacheUsage::ForceUpdate);
// If any of the packages failed to check out, remove them from the set of packages to submit
if ( !SourceControlState.IsValid() || (!SourceControlState->IsCheckedOut() && !SourceControlState->IsAdded() && SourceControlState->IsSourceControlled()) )
{
FilesThatFailedCheckout += FString::Printf( TEXT("%s\n"), *CurPkg->GetName() );
OutPkgsToSubmit.Remove( CurPkg );
}
}
// If any of the packages failed to check out correctly, process the build setting's behavior to see if the build
// should proceed or not
if ( FilesThatFailedCheckout.Len() > 0 )
{
bBuildSuccessful = ProcessAutomatedBuildBehavior( BuildSettings.UnableToCheckoutFilesBehavior,
FText::Format( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_FilesFailedCheckout", "The following assets failed to checkout of source control and cannot be submitted:\n{0}\n\nAttempt to continue the build?"), FText::FromString(FilesThatFailedCheckout)),
OutErrorMessages );
}
}
}
// Verify there are still actually any packages left to submit. If there aren't, abort the build and warn the user of the situation.
if ( bBuildSuccessful )
{
bBuildSuccessful = OutPkgsToSubmit.Num() > 0;
if ( !bBuildSuccessful )
{
LogErrorMessage( NSLOCTEXT("UnrealEd", "AutomatedBuild_Error_NoValidLevels", "None of the current levels are valid for submission; automated build aborted."), OutErrorMessages );
}
}
// If the build is safe to commence, force all of the levels visible to make sure the build operates correctly
if ( bBuildSuccessful )
{
bool bVisibilityToggled = false;
if ( !FLevelUtils::IsLevelVisible( GWorld->PersistentLevel ) )
{
EditorLevelUtils::SetLevelVisibility( GWorld->PersistentLevel, true, false );
bVisibilityToggled = true;
}
for ( TArray<ULevelStreaming*>::TConstIterator LevelIter( GWorld->StreamingLevels ); LevelIter; ++LevelIter )
{
ULevelStreaming* CurStreamingLevel = *LevelIter;
if ( CurStreamingLevel && !FLevelUtils::IsLevelVisible( CurStreamingLevel ) )
{
CurStreamingLevel->bShouldBeVisibleInEditor = true;
bVisibilityToggled = true;
}
}
if ( bVisibilityToggled )
{
GWorld->FlushLevelStreaming();
}
}
return bBuildSuccessful;
}
void UEnvironmentQueryGraph::SpawnMissingNodes()
{
UEnvQuery* QueryOwner = Cast<UEnvQuery>(GetOuter());
if (QueryOwner == nullptr)
{
return;
}
TSet<UEnvQueryTest*> ExistingTests;
TSet<UEnvQueryOption*> ExistingNodes;
TArray<UEnvQueryOption*> OptionsCopy = QueryOwner->GetOptions();
UAIGraphNode* MyRootNode = nullptr;
for (int32 Idx = 0; Idx < Nodes.Num(); Idx++)
{
UEnvironmentQueryGraphNode* MyNode = Cast<UEnvironmentQueryGraphNode>(Nodes[Idx]);
UEnvQueryOption* OptionInstance = MyNode ? Cast<UEnvQueryOption>(MyNode->NodeInstance) : nullptr;
if (OptionInstance && OptionInstance->Generator)
{
ExistingNodes.Add(OptionInstance);
ExistingTests.Empty(ExistingTests.Num());
for (int32 SubIdx = 0; SubIdx < MyNode->SubNodes.Num(); SubIdx++)
{
UEnvironmentQueryGraphNode* MySubNode = Cast<UEnvironmentQueryGraphNode>(MyNode->SubNodes[SubIdx]);
UEnvQueryTest* TestInstance = MySubNode ? Cast<UEnvQueryTest>(MySubNode->NodeInstance) : nullptr;
if (TestInstance)
{
ExistingTests.Add(TestInstance);
}
else
{
MyNode->RemoveSubNode(MySubNode);
SubIdx--;
}
}
SpawnMissingSubNodes(OptionInstance, ExistingTests, MyNode);
}
UEnvironmentQueryGraphNode_Root* RootNode = Cast<UEnvironmentQueryGraphNode_Root>(Nodes[Idx]);
if (RootNode)
{
MyRootNode = RootNode;
}
}
UEdGraphPin* RootOutPin = MyRootNode ? FindGraphNodePin(MyRootNode, EGPD_Output) : nullptr;
ExistingTests.Empty(0);
for (int32 Idx = 0; Idx < OptionsCopy.Num(); Idx++)
{
UEnvQueryOption* OptionInstance = OptionsCopy[Idx];
if (ExistingNodes.Contains(OptionInstance) || OptionInstance == nullptr || OptionInstance->Generator == nullptr)
{
continue;
}
FGraphNodeCreator<UEnvironmentQueryGraphNode_Option> NodeBuilder(*this);
UEnvironmentQueryGraphNode_Option* MyNode = NodeBuilder.CreateNode();
UAIGraphNode::UpdateNodeClassDataFrom(OptionInstance->Generator->GetClass(), MyNode->ClassData);
MyNode->ErrorMessage = MyNode->ClassData.GetDeprecatedMessage();
NodeBuilder.Finalize();
if (MyRootNode)
{
MyNode->NodePosX = MyRootNode->NodePosX + (Idx * 300);
MyNode->NodePosY = MyRootNode->NodePosY + 100;
}
MyNode->NodeInstance = OptionInstance;
SpawnMissingSubNodes(OptionInstance, ExistingTests, MyNode);
UEdGraphPin* SpawnedInPin = FindGraphNodePin(MyNode, EGPD_Input);
if (RootOutPin && SpawnedInPin)
{
RootOutPin->MakeLinkTo(SpawnedInPin);
}
}
}
