static void AppendFilename(const FString& InFilename, TArray<FString>& OutBeautifiedNames, TArray<FString>& OutTestCommands) { // append the filename to the commands we have passed in for(auto Iter(OutBeautifiedNames.CreateIterator()); Iter; Iter++) { *Iter = FString::Printf(TEXT("%s (%s)"), *InFilename, **Iter); } for(auto Iter(OutTestCommands.CreateIterator()); Iter; Iter++) { *Iter += TEXT(" "); *Iter += InFilename; } }
bool UAnimationAsset::ReplaceSkeleton(USkeleton* NewSkeleton, bool bConvertSpaces/*=false*/) { // if it's not same if (NewSkeleton != Skeleton) { // get all sequences that need to change TArray<UAnimSequence*> AnimSeqsToReplace; if (UAnimSequence* AnimSequence = Cast<UAnimSequence>(this)) { AnimSeqsToReplace.AddUnique(AnimSequence); } if (GetAllAnimationSequencesReferred(AnimSeqsToReplace)) { for (auto Iter = AnimSeqsToReplace.CreateIterator(); Iter; ++Iter) { UAnimSequence* AnimSeq = *Iter; if (AnimSeq && AnimSeq->Skeleton != NewSkeleton) { AnimSeq->RemapTracksToNewSkeleton(NewSkeleton, bConvertSpaces); } } } SetSkeleton(NewSkeleton); PostEditChange(); MarkPackageDirty(); return true; } return false; }
void UAnimationGraphSchema::GetStateMachineMenuItems(FGraphContextMenuBuilder& ContextMenuBuilder) const { // Show state machine helpers if ((ContextMenuBuilder.FromPin == NULL) || ((ContextMenuBuilder.FromPin->Direction == EGPD_Input) && (ContextMenuBuilder.FromPin->PinType.PinCategory == PC_Float))) { FString StateCategory(TEXT("State Machines")); // Create the additional entries to get state information TArray<UAnimStateNode*> States; UBlueprint* CurrentBlueprint = FBlueprintEditorUtils::FindBlueprintForGraphChecked(ContextMenuBuilder.CurrentGraph); FBlueprintEditorUtils::GetAllNodesOfClass(CurrentBlueprint, /*out*/ States); for (auto StateIt = States.CreateIterator(); StateIt; ++StateIt) { UAnimStateNode* StateNode = *StateIt; UK2Node_TransitionRuleGetter* NodeTemplate = ContextMenuBuilder.CreateTemplateNode<UK2Node_TransitionRuleGetter>(); NodeTemplate->AssociatedStateNode = StateNode; NodeTemplate->GetterType = ETransitionGetter::ArbitraryState_GetBlendWeight; const FString OwnerName = StateNode->GetOuter()->GetName(); const FString Title = FString::Printf(TEXT("Current %s for state '%s.%s'"), *UK2Node_TransitionRuleGetter::GetFriendlyName(NodeTemplate->GetterType), *OwnerName, *StateNode->GetStateName()); TSharedPtr<FEdGraphSchemaAction_K2NewNode> Action = FK2ActionMenuBuilder::AddNewNodeAction(ContextMenuBuilder, StateCategory, Title, NodeTemplate->GetTooltip(), 0, NodeTemplate->GetKeywords()); Action->NodeTemplate = NodeTemplate; } } }
TSharedPtr< FSurvey > FEpicSurvey::GetBranchSurvey( const FString& Filename ) { TSharedPtr< FSurvey >* Survey = BranchSurveys.Find(Filename); if( Survey == NULL ) { TArray<FCloudFileHeader> Files; TitleCloud->GetFileList(Files); for( auto FileIt=Files.CreateIterator(); FileIt; ++FileIt ) { if( FileIt->FileName == Filename ) { if( TitleCloud->ReadFile(FileIt->DLName) ) { Survey = BranchSurveys.Find(Filename); if( Survey ) { return *Survey; } } return TSharedPtr< FSurvey >(); } } } return *Survey; }
void FSourceControlModule::InitializeSourceControlProviders() { int32 SourceControlCount = IModularFeatures::Get().GetModularFeatureImplementationCount(SourceControlFeatureName); if( SourceControlCount > 0 ) { FString PreferredSourceControlProvider = SourceControlSettings.GetProvider(); TArray<ISourceControlProvider*> Providers = IModularFeatures::Get().GetModularFeatureImplementations<ISourceControlProvider>(SourceControlFeatureName); for(auto It(Providers.CreateIterator()); It; It++) { ISourceControlProvider* Provider = *It; if(PreferredSourceControlProvider == Provider->GetName().ToString()) { CurrentSourceControlProvider = Provider; break; } } // no provider found of this name, default to the first one if( CurrentSourceControlProvider == NULL ) { CurrentSourceControlProvider = &DefaultSourceControlProvider; } } check(CurrentSourceControlProvider); CurrentSourceControlProvider->Init(false); // Don't force a connection here, as its synchronous. Let the user establish a connection. }
int32 UCollisionProfile::LoadCustomResponses(FCollisionResponseTemplate& Template, const UEnum* CollisionChannelEnum, TArray<FResponseChannel>& CustomResponses) const { int32 NumOfItemsCustomized=0; // now loads all custom setups for (auto ChannelIter = CustomResponses.CreateIterator(); ChannelIter; ++ChannelIter) { FResponseChannel& Custom = *ChannelIter; bool bValueFound=false; int32 EnumIndex = ReturnContainerIndexFromChannelName(Custom.Channel); if (EnumIndex != INDEX_NONE) { // use the enum index to set to response to channel Template.ResponseToChannels.EnumArray[EnumIndex] = Custom.Response; bValueFound = true; ++NumOfItemsCustomized; } else { // print error UE_LOG(LogCollisionProfile, Warning, TEXT("Profile (%s) - Custom Channel Name = \'%s\' hasn't been found"), *Template.Name.ToString(), *Custom.Channel.ToString()); } } return (NumOfItemsCustomized == CustomResponses.Num()); }
void GetLaunchOnDeviceID(FString& OutDeviceID, const FString& InMapName) { UAutomationTestSettings const* AutomationTestSettings = GetDefault<UAutomationTestSettings>(); check(AutomationTestSettings); OutDeviceID = "None"; FString LaunchOnDeviceId; for (auto LaunchIter = AutomationTestSettings->LaunchOnSettings.CreateConstIterator(); LaunchIter; LaunchIter++) { FString LaunchOnSettings = LaunchIter->DeviceID; FString LaunchOnMap = FPaths::GetBaseFilename(LaunchIter->LaunchOnTestmap.FilePath); if (LaunchOnMap.Equals(InMapName)) { // shared devices section TSharedPtr<ITargetDeviceServicesModule> TargetDeviceServicesModule = StaticCastSharedPtr<ITargetDeviceServicesModule>(FModuleManager::Get().LoadModule(TEXT("TargetDeviceServices"))); // for each platform... TArray<ITargetDeviceProxyPtr> DeviceProxies; TargetDeviceServicesModule->GetDeviceProxyManager()->GetProxies(FName(*LaunchOnSettings), true, DeviceProxies); // for each proxy... for (auto DeviceProxyIt = DeviceProxies.CreateIterator(); DeviceProxyIt; ++DeviceProxyIt) { ITargetDeviceProxyPtr DeviceProxy = *DeviceProxyIt; if (DeviceProxy->IsConnected()) { OutDeviceID = DeviceProxy->GetTargetDeviceId((FName)*LaunchOnSettings); break; } } } } }
void FKCHandler_ClearDelegate::Compile(FKismetFunctionContext& Context, UEdGraphNode* Node) { UK2Node_BaseMCDelegate* DelegateNode = CastChecked<UK2Node_BaseMCDelegate>(Node); UEdGraphPin* SelfPin = CompilerContext.GetSchema()->FindSelfPin(*DelegateNode, EEdGraphPinDirection::EGPD_Input); check(SelfPin); TArray<UEdGraphPin*> Links = SelfPin->LinkedTo; if(!Links.Num()) { Links.Add(SelfPin); } for (auto NetIt = Links.CreateIterator(); NetIt; ++NetIt) { UEdGraphPin* NetPin = *NetIt; check(NetPin); FBlueprintCompiledStatement& AddStatement = Context.AppendStatementForNode(DelegateNode); AddStatement.Type = KCST_ClearMulticastDelegate; FBPTerminal** VarDelegate = InnerTermMap.Find(FDelegateOwnerId(NetPin, DelegateNode)); check(VarDelegate && *VarDelegate); AddStatement.LHS = *VarDelegate; } GenerateSimpleThenGoto(Context, *DelegateNode, DelegateNode->FindPin(CompilerContext.GetSchema()->PN_Then)); FNodeHandlingFunctor::Compile(Context, DelegateNode); }
void FSequencerActorBindingManager::DeselectAllPuppetObjects() { TArray< AActor* > ActorsToDeselect; for( auto MovieSceneIter( InstanceToPuppetObjectsMap.CreateConstIterator() ); MovieSceneIter; ++MovieSceneIter ) { const TArray< TSharedRef<FPuppetActorInfo> >& PuppetObjects = MovieSceneIter.Value(); for( auto PuppetObjectIter( PuppetObjects.CreateConstIterator() ); PuppetObjectIter; ++PuppetObjectIter ) { if( PuppetObjectIter->Get().GetType() == EPuppetObjectType::Actor ) { TSharedRef< FPuppetActorInfo > PuppetActorInfo = StaticCastSharedRef< FPuppetActorInfo >( *PuppetObjectIter ); AActor* PuppetActor = PuppetActorInfo->PuppetActor.Get(); if( PuppetActor != NULL ) { ActorsToDeselect.Add( PuppetActor ); } } } } if( ActorsToDeselect.Num() > 0 ) { GEditor->GetSelectedActors()->BeginBatchSelectOperation(); GEditor->GetSelectedActors()->MarkBatchDirty(); for( auto ActorIt( ActorsToDeselect.CreateIterator() ); ActorIt; ++ActorIt ) { GEditor->GetSelectedActors()->Deselect( *ActorIt ); } GEditor->GetSelectedActors()->EndBatchSelectOperation(); } }
UK2Node_PlayMovieScene* FSequencerActorBindingManager::FindPlayMovieSceneNodeInLevelScript( const UMovieScene* MovieScene ) const { // Grab the world object for this editor check( MovieScene != NULL ); // Search all levels in the specified world for( TArray<ULevel*>::TConstIterator LevelIter( ActorWorld->GetLevels().CreateConstIterator() ); LevelIter; ++LevelIter ) { auto* Level = *LevelIter; if( Level != NULL ) { // We don't want to create a level script if one doesn't exist yet. We just want to grab the one // that we already have, if one exists. const bool bDontCreate = true; ULevelScriptBlueprint* LSB = Level->GetLevelScriptBlueprint( bDontCreate ); if( LSB != NULL ) { TArray<UK2Node_PlayMovieScene*> EventNodes; FBlueprintEditorUtils::GetAllNodesOfClass( LSB, EventNodes ); for( auto FoundNodeIter( EventNodes.CreateIterator() ); FoundNodeIter; ++FoundNodeIter ) { UK2Node_PlayMovieScene* FoundNode = *FoundNodeIter; if( FoundNode->GetMovieScene() == MovieScene ) { return FoundNode; } } } } } return NULL; }
bool UShooterPersistentUser::IsInvertedYAxisDirty() const { bool bIsDirty = false; if (GEngine) { TArray<APlayerController*> PlayerList; GEngine->GetAllLocalPlayerControllers(PlayerList); for (auto It = PlayerList.CreateIterator(); It; ++It) { APlayerController* PC = *It; if (!PC || !PC->Player || !PC->PlayerInput) { continue; } // Update key bindings for the current user only ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(PC->Player); if(!LocalPlayer || LocalPlayer->ControllerId != UserIndex) { continue; } bIsDirty |= PC->PlayerInput->GetInvertAxis("Lookup") != GetInvertedYAxis(); bIsDirty |= PC->PlayerInput->GetInvertAxis("LookupRate") != GetInvertedYAxis(); } } return bIsDirty; }
void SAnimCurveListRow::OnAnimCurveWeightChanged( float NewWeight ) { float NewValidWeight = FMath::Clamp(NewWeight, -MaxMorphWeight, MaxMorphWeight); Item->Weight = NewValidWeight; Item->bAutoFillData = false; TSharedPtr<SAnimCurveViewer> AnimCurveViewer = AnimCurveViewerPtr.Pin(); if (AnimCurveViewer.IsValid()) { // Add override AnimCurveViewer->AddAnimCurveOverride(Item->SmartName.DisplayName, Item->Weight); // ...then any selected rows need changing by the same delta TArray< TSharedPtr< FDisplayedAnimCurveInfo > > SelectedRows = AnimCurveViewer->AnimCurveListView->GetSelectedItems(); for (auto ItemIt = SelectedRows.CreateIterator(); ItemIt; ++ItemIt) { TSharedPtr< FDisplayedAnimCurveInfo > RowItem = (*ItemIt); if (RowItem != Item) // Don't do "this" row again if it's selected { RowItem->Weight = NewValidWeight; RowItem->bAutoFillData = false; AnimCurveViewer->AddAnimCurveOverride(RowItem->SmartName.DisplayName, RowItem->Weight); } } if(PreviewScenePtr.IsValid()) { PreviewScenePtr.Pin()->InvalidateViews(); } } }
void NUTNet::CleanupUnitTestWorlds() { for (auto It=PendingUnitWorldCleanup.CreateIterator(); It; ++It) { UWorld* CurWorld = *It; // Remove the tick-hook, for this world int32 TickHookIdx = ActiveTickHooks.IndexOfByPredicate( [&CurWorld](const FWorldTickHook* CurTickHook) { return CurTickHook != NULL && CurTickHook->AttachedWorld == CurWorld; }); if (TickHookIdx != INDEX_NONE) { ActiveTickHooks.RemoveAt(TickHookIdx); } GEngine->DestroyWorldContext(CurWorld); CurWorld->DestroyWorld(false); } PendingUnitWorldCleanup.Empty(); // Immediately garbage collect remaining objects, to finish net driver cleanup CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true); }
static void BuildDependencyMapAndCompile(const TArray<UUserDefinedStruct*>& ChangedStructs, FCompilerResultsLog& MessageLog) { struct FDependencyMapEntry { UUserDefinedStruct* Struct; TSet<UUserDefinedStruct*> StructuresToWaitFor; FDependencyMapEntry() : Struct(NULL) {} void Initialize(UUserDefinedStruct* ChangedStruct, const TArray<UUserDefinedStruct*>& AllChangedStructs) { Struct = ChangedStruct; check(Struct); auto Schema = GetDefault<UEdGraphSchema_K2>(); for (auto& VarDesc : FStructureEditorUtils::GetVarDesc(Struct)) { auto StructType = Cast<UUserDefinedStruct>(VarDesc.SubCategoryObject.Get()); if (StructType && (VarDesc.Category == Schema->PC_Struct) && AllChangedStructs.Contains(StructType)) { StructuresToWaitFor.Add(StructType); } } } }; TArray<FDependencyMapEntry> DependencyMap; for (auto Iter = ChangedStructs.CreateConstIterator(); Iter; ++Iter) { DependencyMap.Add(FDependencyMapEntry()); DependencyMap.Last().Initialize(*Iter, ChangedStructs); } while (DependencyMap.Num()) { int32 StructureToCompileIndex = INDEX_NONE; for (int32 EntryIndex = 0; EntryIndex < DependencyMap.Num(); ++EntryIndex) { if(0 == DependencyMap[EntryIndex].StructuresToWaitFor.Num()) { StructureToCompileIndex = EntryIndex; break; } } check(INDEX_NONE != StructureToCompileIndex); UUserDefinedStruct* Struct = DependencyMap[StructureToCompileIndex].Struct; check(Struct); FUserDefinedStructureCompilerInner::CleanAndSanitizeStruct(Struct); FUserDefinedStructureCompilerInner::InnerCompileStruct(Struct, GetDefault<UEdGraphSchema_K2>(), MessageLog); DependencyMap.RemoveAtSwap(StructureToCompileIndex); for (auto EntryIter = DependencyMap.CreateIterator(); EntryIter; ++EntryIter) { (*EntryIter).StructuresToWaitFor.Remove(Struct); } } }
void FPendingDelete::CheckForReferences() { if ( bReferencesChecked ) { return; } bReferencesChecked = true; // Load the asset registry module FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>( TEXT( "AssetRegistry" ) ); AssetRegistryModule.Get().GetReferencers(Object->GetOutermost()->GetFName(), DiskReferences); // Check and see whether we are referenced by any objects that won't be garbage collected (*including* the undo buffer) FReferencerInformationList ReferencesIncludingUndo; bool bReferencedInMemoryOrUndoStack = IsReferenced(Object, GARBAGE_COLLECTION_KEEPFLAGS, true, &ReferencesIncludingUndo); // Determine the in-memory references, *excluding* the undo buffer GEditor->Trans->DisableObjectSerialization(); bIsReferencedInMemoryByNonUndo = IsReferenced(Object, GARBAGE_COLLECTION_KEEPFLAGS, true, &MemoryReferences); GEditor->Trans->EnableObjectSerialization(); // see if this object is the transaction buffer - set a flag so we know we need to clear the undo stack const int32 TotalReferenceCount = ReferencesIncludingUndo.ExternalReferences.Num() + ReferencesIncludingUndo.InternalReferences.Num(); const int32 NonUndoReferenceCount = MemoryReferences.ExternalReferences.Num() + MemoryReferences.InternalReferences.Num(); bIsReferencedInMemoryByUndo = TotalReferenceCount > NonUndoReferenceCount; // If the object itself isn't in the transaction buffer, check to see if it's a Blueprint asset. We might have instances of the // Blueprint in the transaction buffer, in which case we also want to both alert the user and clear it prior to deleting the asset. if ( !bIsReferencedInMemoryByUndo ) { UBlueprint* Blueprint = Cast<UBlueprint>( Object ); if ( Blueprint && Blueprint->GeneratedClass ) { TArray<FReferencerInformation> ExternalMemoryReferences = MemoryReferences.ExternalReferences; for ( auto RefIt = ExternalMemoryReferences.CreateIterator(); RefIt && !bIsReferencedInMemoryByUndo; ++RefIt ) { FReferencerInformation& RefInfo = *RefIt; if ( RefInfo.Referencer->IsA( Blueprint->GeneratedClass ) ) { if ( IsReferenced( RefInfo.Referencer, GARBAGE_COLLECTION_KEEPFLAGS, true, &ReferencesIncludingUndo ) ) { GEditor->Trans->DisableObjectSerialization(); FReferencerInformationList ReferencesExcludingUndo; if ( IsReferenced( RefInfo.Referencer, GARBAGE_COLLECTION_KEEPFLAGS, true, &ReferencesExcludingUndo ) ) { bIsReferencedInMemoryByUndo = ( ReferencesIncludingUndo.InternalReferences.Num() + ReferencesIncludingUndo.ExternalReferences.Num() ) > ( ReferencesExcludingUndo.InternalReferences.Num() + ReferencesExcludingUndo.ExternalReferences.Num() ); } GEditor->Trans->EnableObjectSerialization(); } } } } } }
void FAssetFixUpRedirectors::DeleteRedirectors(TArray<FRedirectorRefs>& RedirectorsToFix) const { TArray<UObject*> ObjectsToDelete; for ( auto RedirectorIt = RedirectorsToFix.CreateIterator(); RedirectorIt; ++RedirectorIt ) { FRedirectorRefs& RedirectorRefs = *RedirectorIt; if ( RedirectorRefs.bRedirectorValidForFixup ) { // Add all redirectors found in this package to the redirectors to delete list. // All redirectors in this package should be fixed up. UPackage* RedirectorPackage = RedirectorRefs.Redirector->GetOutermost(); TArray<UObject*> AssetsInRedirectorPackage; GetObjectsWithOuter(RedirectorPackage, AssetsInRedirectorPackage, /*bIncludeNestedObjects=*/false); UMetaData* PackageMetaData = NULL; bool bContainsAtLeastOneOtherAsset = false; for ( auto ObjIt = AssetsInRedirectorPackage.CreateConstIterator(); ObjIt; ++ObjIt ) { if ( UObjectRedirector* Redirector = Cast<UObjectRedirector>(*ObjIt) ) { Redirector->RemoveFromRoot(); ObjectsToDelete.Add(Redirector); } else if ( UMetaData* MetaData = Cast<UMetaData>(*ObjIt) ) { PackageMetaData = MetaData; } else { bContainsAtLeastOneOtherAsset = true; } } if ( !bContainsAtLeastOneOtherAsset ) { RedirectorPackage->RemoveFromRoot(); ULinkerLoad* Linker = ULinkerLoad::FindExistingLinkerForPackage(RedirectorPackage); if ( Linker ) { Linker->RemoveFromRoot(); } // @todo we shouldnt be worrying about metadata objects here, ObjectTools::CleanUpAfterSuccessfulDelete should if ( PackageMetaData ) { PackageMetaData->RemoveFromRoot(); ObjectsToDelete.Add(PackageMetaData); } } // This redirector will be deleted, NULL the reference here RedirectorRefs.Redirector = NULL; } } if ( ObjectsToDelete.Num() > 0 ) { ObjectTools::DeleteObjects(ObjectsToDelete); } }
void FAssetFixUpRedirectors::PopulateRedirectorReferencers(TArray<FRedirectorRefs>& RedirectorsToPopulate) const { FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry"); for ( auto RedirectorRefsIt = RedirectorsToPopulate.CreateIterator(); RedirectorRefsIt; ++RedirectorRefsIt ) { FRedirectorRefs& RedirectorRefs = *RedirectorRefsIt; AssetRegistryModule.Get().GetReferencers(RedirectorRefs.RedirectorPackageName, RedirectorRefs.ReferencingPackageNames); } }
void FOnlineAsyncTaskManager::Tick() { // parallel Q. FOnlineAsyncTask* Task = NULL; // Tick Online services ( possibly callbacks ). OnlineTick(); // Tick all the parallel tasks - Tick unrelated tasks together. // Create a copy of existing tasks. TArray<FOnlineAsyncTask*> CopyParallelTasks = ParallelTasks; // Iterate. for (auto it = CopyParallelTasks.CreateIterator(); it; ++it) { Task = *it; Task->Tick(); if (Task->IsDone()) { UE_LOG(LogOnline, Log, TEXT("Async parallel Task '%s' completed in %f seconds with %d (Parallel)"), *Task->ToString(), Task->GetElapsedTime(), Task->WasSuccessful()); // Task is done, fixup the original parallel task queue. RemoveFromParallelTasks(Task); AddToOutQueue(Task); } } // Serial Q. if (InQueue.Num() == 0) return; // Pick up the first element in the queue ( "current task" ). Task = InQueue[0]; // Needed ? if (Task == NULL) return; Task->Tick(); if (Task->IsDone()) { UE_LOG(LogOnline, Log, TEXT("Async serial task '%s' completed in %f seconds with %d"), *Task->ToString(), Task->GetElapsedTime(), Task->WasSuccessful()); // Task is done, remove from the incoming queue and add to the outgoing queue PopFromInQueue(); AddToOutQueue(Task); } }
FString UStringUtilities::JoinStringsWithNewlines(TArray<FString> strings) { FString result; for ( auto Itr(strings.CreateIterator()); Itr; Itr++ ) { result.Append(*Itr); if ( Itr + 1 ) { result.Append("\n"); } } return result; }
void FAssetFixUpRedirectors::LoadReferencingPackages(TArray<FRedirectorRefs>& RedirectorsToFix, TArray<UPackage*>& OutReferencingPackagesToSave) const { FScopedSlowTask SlowTask( RedirectorsToFix.Num(), LOCTEXT( "LoadingReferencingPackages", "Loading Referencing Packages..." ) ); SlowTask.MakeDialog(); ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider(); // Load all packages that reference each redirector, if possible for ( auto RedirectorRefsIt = RedirectorsToFix.CreateIterator(); RedirectorRefsIt; ++RedirectorRefsIt ) { SlowTask.EnterProgressFrame(1); FRedirectorRefs& RedirectorRefs = *RedirectorRefsIt; if ( ISourceControlModule::Get().IsEnabled() ) { FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(RedirectorRefs.Redirector->GetOutermost(), EStateCacheUsage::Use); const bool bValidSCCState = !SourceControlState.IsValid() || SourceControlState->IsAdded() || SourceControlState->IsCheckedOut() || SourceControlState->CanCheckout() || !SourceControlState->IsSourceControlled() || SourceControlState->IsIgnored(); if ( !bValidSCCState ) { RedirectorRefs.bRedirectorValidForFixup = false; RedirectorRefs.FailureReason = LOCTEXT("RedirectorFixupFailed_BadSCC", "Redirector could not be checked out or marked for delete"); } } // Load all referencers for ( auto PackageNameIt = RedirectorRefs.ReferencingPackageNames.CreateConstIterator(); PackageNameIt; ++PackageNameIt ) { const FString PackageName = (*PackageNameIt).ToString(); // Find the package in memory. If it is not in memory, try to load it UPackage* Package = FindPackage(NULL, *PackageName); if ( !Package ) { Package = LoadPackage(NULL, *PackageName, LOAD_None); } if ( Package ) { if ( Package->PackageFlags & PKG_CompiledIn ) { // This is a script reference RedirectorRefs.bRedirectorValidForFixup = false; RedirectorRefs.FailureReason = FText::Format(LOCTEXT("RedirectorFixupFailed_CodeReference", "Redirector is referenced by code. Package: {0}"), FText::FromString(PackageName)); } else { // If we found a valid package, mark it for save OutReferencingPackagesToSave.AddUnique(Package); } } } } }
/** * Takes two blueprints and compares them (as if we were running the in-editor * diff tool). Any discrepancies between the two graphs will be listed in the DiffsOut array. * * @param LhsBlueprint The baseline blueprint you wish to compare against. * @param RhsBlueprint The blueprint you wish to look for changes in. * @param DiffsOut An output list that will contain any graph internal differences that were found. * @return True if the two blueprints differ, false if they are identical. */ static bool DiffBlueprints(UBlueprint* const LhsBlueprint, UBlueprint* const RhsBlueprint, TArray<FDiffSingleResult>& DiffsOut) { TArray<UEdGraph*> LhsGraphs; LhsBlueprint->GetAllGraphs(LhsGraphs); TArray<UEdGraph*> RhsGraphs; RhsBlueprint->GetAllGraphs(RhsGraphs); bool bDiffsFound = false; // walk the graphs in the rhs blueprint (because, conceptually, it is the more up to date one) for (auto RhsGraphIt(RhsGraphs.CreateIterator()); RhsGraphIt; ++RhsGraphIt) { UEdGraph* RhsGraph = *RhsGraphIt; UEdGraph* LhsGraph = NULL; // search for the corresponding graph in the lhs blueprint for (auto LhsGraphIt(LhsGraphs.CreateIterator()); LhsGraphIt; ++LhsGraphIt) { // can't trust the guid until we've done a resave on every asset //if ((*LhsGraphIt)->GraphGuid == RhsGraph->GraphGuid) // name compares is probably sufficient, but just so we don't always do a string compare if (((*LhsGraphIt)->GetClass() == RhsGraph->GetClass()) && ((*LhsGraphIt)->GetName() == RhsGraph->GetName())) { LhsGraph = *LhsGraphIt; break; } } // if a matching graph wasn't found in the lhs blueprint, then that is a BIG inconsistency if (LhsGraph == NULL) { bDiffsFound = true; continue; } bDiffsFound |= FGraphDiffControl::DiffGraphs(LhsGraph, RhsGraph, DiffsOut); } return bDiffsFound; }
void FSCSEditorViewportClient::BeginTransaction(const FText& Description) { //UE_LOG(LogSCSEditorViewport, Log, TEXT("FSCSEditorViewportClient::BeginTransaction() pre: %s %08x"), SessionName, *((uint32*)&ScopedTransaction)); if(!ScopedTransaction) { ScopedTransaction = new FScopedTransaction(Description); auto BlueprintEditor = BlueprintEditorPtr.Pin(); if (BlueprintEditor.IsValid()) { UBlueprint* PreviewBlueprint = BlueprintEditor->GetBlueprintObj(); if (PreviewBlueprint != nullptr) { FBlueprintEditorUtils::MarkBlueprintAsModified(PreviewBlueprint); } TArray<FSCSEditorTreeNodePtrType> SelectedNodes = BlueprintEditor->GetSelectedSCSEditorTreeNodes(); for(auto SelectedSCSNodeIter(SelectedNodes.CreateIterator()); SelectedSCSNodeIter; ++SelectedSCSNodeIter) { FSCSEditorTreeNodePtrType Node = *SelectedSCSNodeIter; if(Node.IsValid()) { if(USCS_Node* SCS_Node = Node->GetSCSNode()) { SCS_Node->Modify(); } // Modify both the component template and the instance in the preview actor (provided there is one) UActorComponent* ComponentTemplate = Node->GetEditableComponentTemplate(PreviewBlueprint); if (ComponentTemplate != nullptr) { ComponentTemplate->SetFlags(RF_Transactional); ComponentTemplate->Modify(); } AActor* PreviewActor = GetPreviewActor(); if (PreviewActor) { UActorComponent* ComponentPreviewInstance = Node->FindComponentInstanceInActor(PreviewActor); if (ComponentPreviewInstance != nullptr) { ComponentPreviewInstance->SetFlags(RF_Transactional); ComponentPreviewInstance->Modify(); } } } } } } //UE_LOG(LogSCSEditorViewport, Log, TEXT("FSCSEditorViewportClient::BeginTransaction() post: %s %08x"), SessionName, *((uint32*)&ScopedTransaction)); }
void FGAActiveEffectContainer::RemoveTargetAggregation(TSharedPtr<FGAActiveDuration> EffectIn) { TArray<FGAEffectHandle>* handles; handles = MyEffects.Find(EffectIn->EffectName); for (auto It = handles->CreateIterator(); It; ++It) { if (*It == EffectIn->MyHandle) { handles->RemoveAtSwap(It.GetIndex()); } } }
void AFastBox::NormalizeWorldSpeed() { Cast<AMazeRunBall>(GetWorld()->GetFirstPlayerController()->GetPawn())->CustomTimeDilation = 1.0f; Cast<AMazeRunBall>(GetWorld()->GetFirstPlayerController()->GetPawn())->Music->SetPitchMultiplier(1.0f); UGameplayStatics::SetGlobalTimeDilation(this, 1.0f); TArray<AActor*> spikes; UGameplayStatics::GetAllActorsOfClass(this, ADeathSpike::StaticClass(), spikes); for (auto Iter(spikes.CreateIterator()); Iter; Iter++) { Cast<ADeathSpike>(*Iter)->TimeDilation = 1.0f; } }
FA3NodeOptionalPinManager(class UAnimGraphNode_Base* Node, TArray<UEdGraphPin*>* InOldPins) : BaseNode(Node) , OldPins(InOldPins) { if (OldPins != NULL) { for (auto PinIt = OldPins->CreateIterator(); PinIt; ++PinIt) { UEdGraphPin* Pin = *PinIt; OldPinMap.Add(Pin->PinName, Pin); } } }
FReply SContentReference::OnClickUseButton() { TArray<FAssetData> Objects; FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser")); ContentBrowserModule.Get().GetSelectedAssets(Objects); for(auto It(Objects.CreateIterator());It;++It) { OnSetReference.ExecuteIfBound(It->GetAsset()); } return FReply::Handled(); }
void ConditionTranslationMetadata( TSharedRef<FLocMetadataValue> MetadataValue ) { switch( MetadataValue->Type ) { case ELocMetadataType::String: { TSharedPtr<FLocMetadataValue> MetadataValuePtr = MetadataValue; TSharedPtr<FLocMetadataValueString> MetadataString = StaticCastSharedPtr<FLocMetadataValueString>( MetadataValuePtr ); MetadataString->SetString( TEXT("") ); } break; case ELocMetadataType::Array: { TArray< TSharedPtr< FLocMetadataValue > > MetadataArray = MetadataValue->AsArray(); for( auto ArrayIter = MetadataArray.CreateIterator(); ArrayIter; ++ArrayIter ) { TSharedPtr<FLocMetadataValue>& Item = *ArrayIter; if( Item.IsValid() ) { ConditionTranslationMetadata( Item.ToSharedRef() ); } } } break; case ELocMetadataType::Object: { TSharedPtr< FLocMetadataObject > MetadataObject = MetadataValue->AsObject(); for( auto ValueIter = MetadataObject->Values.CreateConstIterator(); ValueIter; ++ValueIter ) { const FString Name = (*ValueIter).Key; TSharedPtr< FLocMetadataValue > Value = (*ValueIter).Value; if( Value.IsValid() ) { if( Value->Type == ELocMetadataType::String ) { MetadataObject->SetStringField( Name, TEXT("") ); } else { ConditionTranslationMetadata( Value.ToSharedRef() ); } } } } default: break; } }
void UK2Node_TransitionRuleGetter::GetStateSpecificMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar, const UAnimBlueprint* AnimBlueprint) const { TArray<UAnimStateNode*> States; FBlueprintEditorUtils::GetAllNodesOfClass(AnimBlueprint, /*out*/ States); // Go through all states to generate possible menu actions for (auto StateIt = States.CreateIterator(); StateIt; ++StateIt) { UAnimStateNode* StateNode = *StateIt; GetStateSpecificAnimGraphSchemaMenuActions(ActionRegistrar, AnimBlueprint, StateNode); GetStateSpecificAnimTransitionSchemaMenuActions(ActionRegistrar, AnimBlueprint, StateNode); } }
bool FAssetFixUpRedirectors::CheckOutReferencingPackages(TArray<FRedirectorRefs>& RedirectorsToFix, TArray<UPackage*>& InOutReferencingPackagesToSave) const { // Prompt to check out all successfully loaded packages bool bUserAcceptedCheckout = true; if ( InOutReferencingPackagesToSave.Num() > 0 ) { if ( ISourceControlModule::Get().IsEnabled() ) { TArray<UPackage*> PackagesCheckedOutOrMadeWritable; TArray<UPackage*> PackagesNotNeedingCheckout; bUserAcceptedCheckout = FEditorFileUtils::PromptToCheckoutPackages( false, InOutReferencingPackagesToSave, &PackagesCheckedOutOrMadeWritable, &PackagesNotNeedingCheckout ); if ( bUserAcceptedCheckout ) { TArray<UPackage*> PackagesThatCouldNotBeCheckedOut = InOutReferencingPackagesToSave; for ( auto PackageIt = PackagesCheckedOutOrMadeWritable.CreateConstIterator(); PackageIt; ++PackageIt ) { PackagesThatCouldNotBeCheckedOut.Remove(*PackageIt); } for ( auto PackageIt = PackagesNotNeedingCheckout.CreateConstIterator(); PackageIt; ++PackageIt ) { PackagesThatCouldNotBeCheckedOut.Remove(*PackageIt); } for ( auto PackageIt = PackagesThatCouldNotBeCheckedOut.CreateConstIterator(); PackageIt; ++PackageIt ) { const FName NonCheckedOutPackageName = (*PackageIt)->GetFName(); for ( auto RedirectorRefsIt = RedirectorsToFix.CreateIterator(); RedirectorRefsIt; ++RedirectorRefsIt ) { FRedirectorRefs& RedirectorRefs = *RedirectorRefsIt; if ( RedirectorRefs.ReferencingPackageNames.Contains(NonCheckedOutPackageName) ) { // We did not check out at least one of the packages we needed to. This redirector can not be fixed up. RedirectorRefs.FailureReason = FText::Format(LOCTEXT("RedirectorFixupFailed_NotCheckedOut", "Referencing package {0} was not checked out"), FText::FromName(NonCheckedOutPackageName)); RedirectorRefs.bRedirectorValidForFixup = false; } } InOutReferencingPackagesToSave.Remove(*PackageIt); } } } } return bUserAcceptedCheckout; }
bool FAssetTypeActions_Curve::CanReimportCurves( TArray<TWeakObjectPtr<UCurveBase>> Objects )const { for(auto It = Objects.CreateIterator();It;++It) { auto& Obj = *It; if(UCurveBase* Curve = Obj.Get()) { if(!Curve->ImportPath.IsEmpty()) { return true; } } } return false; }