/** Parse the array of strings results of a 'git status' command * * Example git status results: M Content/Textures/T_Perlin_Noise_M.uasset R Content/Textures/T_Perlin_Noise_M.uasset -> Content/Textures/T_Perlin_Noise_M2.uasset ?? Content/Materials/M_Basic_Wall.uasset !! BasicCode.sln */ static void ParseStatusResults(const TArray<FString>& InFiles, const TArray<FString>& InResults, TArray<FGitSourceControlState>& OutStates) { // Iterate on all files explicitely listed in the command for(const auto& File : InFiles) { FGitSourceControlState FileState(File); // Search the file in the list of status int32 IdxResult = InResults.IndexOfByPredicate(FGitStatusFileMatcher(File)); if(IdxResult != INDEX_NONE) { // File found in status results; only the case for "changed" files FGitStatusParser StatusParser(InResults[IdxResult]); FileState.WorkingCopyState = StatusParser.State; } else { // File not found in status if(FPaths::FileExists(File)) { // usually means the file is unchanged, FileState.WorkingCopyState = EWorkingCopyState::Unchanged; } else { // but also the case for newly created content: there is no file on disk until the content is saved for the first time FileState.WorkingCopyState = EWorkingCopyState::NotControlled; } } FileState.TimeStamp.Now(); OutStates.Add(FileState); } }
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 inline void AddIdToMuteList(TArray< TSharedRef<const FUniqueNetId> >& MuteList, const TSharedPtr<const FUniqueNetId>& UniqueIdToAdd) { FUniqueNetIdMatcher UniqueIdToAddMatch(*UniqueIdToAdd); if (MuteList.IndexOfByPredicate(UniqueIdToAddMatch) == INDEX_NONE) { MuteList.Add(UniqueIdToAdd.ToSharedRef()); } }
static inline void RemoveIdFromMuteList(TArray< TSharedRef<const FUniqueNetId> >& MuteList, const TSharedPtr<const FUniqueNetId>& UniqueIdToRemove) { FUniqueNetIdMatcher UniqueIdToRemoveMatch(*UniqueIdToRemove); int32 RemoveIndex = MuteList.IndexOfByPredicate(UniqueIdToRemoveMatch); if (RemoveIndex != INDEX_NONE) { MuteList.RemoveAtSwap(RemoveIndex); } }
static void AddSortedSpriteInfo(TArray<FSpriteCategoryInfo>& InOutSortedSpriteInfo, const FSpriteCategoryInfo& InSpriteInfo ) { const FSpriteCategoryInfo* ExistingSpriteInfo = InOutSortedSpriteInfo.FindByPredicate([&InSpriteInfo](const FSpriteCategoryInfo& SpriteInfo){ return InSpriteInfo.Category == SpriteInfo.Category; }); if (ExistingSpriteInfo != NULL) { //Already present checkSlow(ExistingSpriteInfo->DisplayName.EqualTo(InSpriteInfo.DisplayName)); //Catch mismatches between DisplayNames } else { // Add the category to the correct position in the array to keep it sorted const int32 CatIndex = InOutSortedSpriteInfo.IndexOfByPredicate([&InSpriteInfo](const FSpriteCategoryInfo& SpriteInfo){ return InSpriteInfo.DisplayName.CompareTo( SpriteInfo.DisplayName ) < 0; }); if (CatIndex != INDEX_NONE) { InOutSortedSpriteInfo.Insert( InSpriteInfo, CatIndex ); } else { InOutSortedSpriteInfo.Add( InSpriteInfo ); } } }
FLocalizationConfigurationScript GenerateExportScript(const FLocalizationTargetSettings& Target, const TOptional<FString> CultureName, const TOptional<FString> OutputPathOverride) { FLocalizationConfigurationScript Script; const FString ContentDirRelativeToGameDir = MakePathRelativeToProjectDirectory(FPaths::GameContentDir()); // GatherTextStep0 - InternationalizationExport { FConfigSection& ConfigSection = Script.GatherTextStep(0); // CommandletClass ConfigSection.Add( TEXT("CommandletClass"), TEXT("InternationalizationExport") ); ConfigSection.Add( TEXT("bExportLoc"), TEXT("true") ); const FString SourcePath = ContentDirRelativeToGameDir / TEXT("Localization") / Target.Name; ConfigSection.Add( TEXT("SourcePath"), SourcePath ); FString DestinationPath; // Overriding output path changes the destination directory for the PO file. if (OutputPathOverride.IsSet()) { // The output path for a specific culture is a file path. if (CultureName.IsSet()) { DestinationPath = MakePathRelativeToProjectDirectory( FPaths::GetPath(OutputPathOverride.GetValue()) ); } // Otherwise, it is a directory path. else { DestinationPath = MakePathRelativeToProjectDirectory( OutputPathOverride.GetValue() ); } } // Use the default PO file's directory path. else { DestinationPath = ContentDirRelativeToGameDir / TEXT("Localization") / Target.Name; } ConfigSection.Add( TEXT("DestinationPath"), DestinationPath ); TArray<const FCultureStatistics*> AllCultureStatistics; AllCultureStatistics.Add(&Target.NativeCultureStatistics); for (const FCultureStatistics& SupportedCultureStatistics : Target.SupportedCulturesStatistics) { AllCultureStatistics.Add(&SupportedCultureStatistics); } const auto& AddCultureToGenerate = [&](const int32 Index) { ConfigSection.Add( TEXT("CulturesToGenerate"), AllCultureStatistics[Index]->CultureName ); }; // Export for a specific culture. if (CultureName.IsSet()) { const int32 CultureIndex = AllCultureStatistics.IndexOfByPredicate([CultureName](const FCultureStatistics* Culture) { return Culture->CultureName == CultureName.GetValue(); }); AddCultureToGenerate(CultureIndex); } // Export for all cultures. else { for (int32 CultureIndex = 0; CultureIndex < AllCultureStatistics.Num(); ++CultureIndex) { AddCultureToGenerate(CultureIndex); } } // Do not use culture subdirectories if exporting a single culture to a specific directory. if (CultureName.IsSet() && OutputPathOverride.IsSet()) { ConfigSection.Add( TEXT("bUseCultureDirectory"), "false" ); } ConfigSection.Add( TEXT("ManifestName"), FPaths::GetCleanFilename(GetManifestPath(Target)) ); ConfigSection.Add( TEXT("ArchiveName"), FPaths::GetCleanFilename(GetArchivePath(Target, FString())) ); FString POFileName; // The output path for a specific culture is a file path. if (CultureName.IsSet() && OutputPathOverride.IsSet()) { POFileName = FPaths::GetCleanFilename( OutputPathOverride.GetValue() ); } // Use the default PO file's name. else { POFileName = FPaths::GetCleanFilename( GetDefaultPOPath( Target, CultureName.Get( TEXT("") ) ) ); } ConfigSection.Add( TEXT("PortableObjectName"), POFileName ); } Script.Dirty = true; return Script; }
TArray<FArrangedWidget> FHittestGrid::GetBubblePath( FVector2D DesktopSpaceCoordinate, bool bIgnoreEnabledStatus ) { if (WidgetsCachedThisFrame->Num() > 0 && Cells.Num() > 0) { const FVector2D CursorPositionInGrid = DesktopSpaceCoordinate - GridOrigin; const FIntPoint CellCoordinate = FIntPoint( FMath::Min( FMath::Max(FMath::FloorToInt(CursorPositionInGrid.X / CellSize.X), 0), NumCells.X-1), FMath::Min( FMath::Max(FMath::FloorToInt(CursorPositionInGrid.Y / CellSize.Y), 0), NumCells.Y-1 ) ); static FVector2D LastCoordinate = FVector2D::ZeroVector; if ( LastCoordinate != CursorPositionInGrid ) { LastCoordinate = CursorPositionInGrid; } checkf( (CellCoordinate.Y*NumCells.X + CellCoordinate.X) < Cells.Num(), TEXT("Index out of range, CellCoordinate is: %d %d CursorPosition is: %f %f"), CellCoordinate.X, CellCoordinate.Y, CursorPositionInGrid.X, CursorPositionInGrid.Y ); const TArray<int32>& IndexesInCell = CellAt( CellCoordinate.X, CellCoordinate.Y ).CachedWidgetIndexes; int32 HitWidgetIndex = INDEX_NONE; // Consider front-most widgets first for hittesting. for ( int32 i = IndexesInCell.Num()-1; i>=0 && HitWidgetIndex==INDEX_NONE; --i ) { check( IndexesInCell[i] < WidgetsCachedThisFrame->Num() ); const FCachedWidget& TestCandidate = (*WidgetsCachedThisFrame)[IndexesInCell[i]]; // Compute the render space clipping rect (FGeometry exposes a layout space clipping rect). FSlateRotatedRect DesktopOrientedClipRect = TransformRect( Concatenate( Inverse(TestCandidate.CachedGeometry.GetAccumulatedLayoutTransform()), TestCandidate.CachedGeometry.GetAccumulatedRenderTransform() ), FSlateRotatedRect(TestCandidate.CachedGeometry.GetClippingRect().IntersectionWith(TestCandidate.ClippingRect)) ); if (DesktopOrientedClipRect.IsUnderLocation(DesktopSpaceCoordinate) && TestCandidate.WidgetPtr.IsValid()) { HitWidgetIndex = IndexesInCell[i]; } } if (HitWidgetIndex != INDEX_NONE) { TArray<FArrangedWidget> BubblePath; int32 CurWidgetIndex=HitWidgetIndex; bool bPathUninterrupted = false; do { check( CurWidgetIndex < WidgetsCachedThisFrame->Num() ); const FCachedWidget& CurCachedWidget = (*WidgetsCachedThisFrame)[CurWidgetIndex]; const TSharedPtr<SWidget> CachedWidgetPtr = CurCachedWidget.WidgetPtr.Pin(); bPathUninterrupted = CachedWidgetPtr.IsValid(); if (bPathUninterrupted) { BubblePath.Insert(FArrangedWidget(CachedWidgetPtr.ToSharedRef(), CurCachedWidget.CachedGeometry), 0); CurWidgetIndex = CurCachedWidget.ParentIndex; } } while (CurWidgetIndex != INDEX_NONE && bPathUninterrupted); if (!bPathUninterrupted) { // A widget in the path to the root has been removed, so anything // we thought we had hittest is no longer actually there. // Pretend we didn't hit anything. BubblePath = TArray<FArrangedWidget>(); } // Disabling a widget disables all of its logical children // This effect is achieved by truncating the path to the // root-most enabled widget. if ( !bIgnoreEnabledStatus ) { const int32 DisabledWidgetIndex = BubblePath.IndexOfByPredicate( []( const FArrangedWidget& SomeWidget ){ return !SomeWidget.Widget->IsEnabled( ); } ); if (DisabledWidgetIndex != INDEX_NONE) { BubblePath.RemoveAt( DisabledWidgetIndex, BubblePath.Num() - DisabledWidgetIndex ); } } return BubblePath; } else { return TArray<FArrangedWidget>(); } } else { return TArray<FArrangedWidget>(); } }