void UFlareAIBehavior::Simulate() { SCOPE_CYCLE_COUNTER(STAT_FlareAIBehavior_Simulate); // See how the player is doing TArray<UFlareCompany*> SortedCompany = Game->GetGameWorld()->GetCompanies(); SortedCompany.Sort(&CompanyValueComparator); int32 PlayerCompanyIndex = SortedCompany.IndexOfByKey(GetGame()->GetPC()->GetCompany()); int32 PlayerArmy = GetGame()->GetPC()->GetCompany()->GetCompanyValue().ArmyCurrentCombatPoints; // Pirates hate you if (PlayerCompanyIndex > 0 && Company == ST->Pirates) { Company->GivePlayerReputation(-0.5); } // Competitors hate you more if you're doing well float ReputationLoss = PlayerCompanyIndex / 30.f; if (PlayerArmy > 0 && Company != ST->AxisSupplies && Company->GetPlayerReputation() > ReputationLoss) { Company->GivePlayerReputation(-ReputationLoss); } // Simulate the day if (Company == ST->Pirates) { SimulatePirateBehavior(); } else { SimulateGeneralBehavior(); } }
bool FLocMetadataValueArray::EqualTo( const FLocMetadataValue& Other ) const { const FLocMetadataValueArray* OtherObj = (FLocMetadataValueArray*) &Other; if( Value.Num() != OtherObj->Value.Num() ) { return false; } TArray< TSharedPtr<FLocMetadataValue> > Sorted = Value; TArray< TSharedPtr<FLocMetadataValue> > OtherSorted = OtherObj->Value; Sorted.Sort( FCompareMetadataValue() ); OtherSorted.Sort( FCompareMetadataValue() ); for( int32 idx = 0; idx < Sorted.Num(); ++idx ) { if( !(*(Sorted[idx]) == *(OtherSorted[idx]) ) ) { return false; } } return true; }
bool FLocMetadataValueArray::LessThan( const FLocMetadataValue& Other ) const { const FLocMetadataValueArray* OtherObj = (FLocMetadataValueArray*) &Other; TArray< TSharedPtr<FLocMetadataValue> > Sorted = Value; TArray< TSharedPtr<FLocMetadataValue> > OtherSorted = OtherObj->Value; Sorted.Sort( FCompareMetadataValue() ); OtherSorted.Sort( FCompareMetadataValue() ); for( int32 idx = 0; idx < Sorted.Num(); ++idx ) { if( idx >= OtherSorted.Num() ) { return false; } else if( !( *(Sorted[idx]) == *(OtherSorted[idx]) ) ) { return *(Sorted[idx]) < *(OtherSorted[idx]); } } if( OtherSorted.Num() > Sorted.Num() ) { return true; } return false; }
FProfilerManager::FProfilerManager( const ISessionManagerRef& InSessionManager ) : SessionManager( InSessionManager ) , CommandList( new FUICommandList() ) , ProfilerActionManager( this ) , Settings() , ProfilerType( EProfilerSessionTypes::InvalidOrMax ) , bLivePreview( false ) , bHasCaptureFileFullyProcessed( false ) { FEventGraphSample::InitializePropertyManagement(); #if 0 // Performance tests. static FTotalTimeAndCount CurrentNative(0.0f, 0); static FTotalTimeAndCount CurrentPointer(0.0f, 0); static FTotalTimeAndCount CurrentShared(0.0f, 0); for( int32 Lx = 0; Lx < 16; ++Lx ) { FRandomStream RandomStream( 666 ); TArray<FEventGraphSample> EventsNative; TArray<FEventGraphSample*> EventsPointer; TArray<FEventGraphSamplePtr> EventsShared; const int32 NumEvents = 16384; for( int32 Nx = 0; Nx < NumEvents; ++Nx ) { const double Rnd = RandomStream.FRandRange( 0.0f, 16384.0f ); const FString EventName = TTypeToString<double>::ToString( Rnd ); FEventGraphSample NativeEvent( *EventName ); NativeEvent._InclusiveTimeMS = Rnd; FEventGraphSamplePtr SharedEvent = FEventGraphSample::CreateNamedEvent( *EventName ); SharedEvent->_InclusiveTimeMS = Rnd; EventsNative.Add(NativeEvent); EventsPointer.Add(SharedEvent.Get()); EventsShared.Add(SharedEvent); } { FProfilerScopedLogTime ScopedLog( TEXT("1.NativeSorting"), &CurrentNative ); EventsNative.Sort( FEventGraphSampleLess() ); } { FProfilerScopedLogTime ScopedLog( TEXT("2PointerSorting"), &CurrentPointer ); EventsPointer.Sort( FEventGraphSampleLess() ); } { FProfilerScopedLogTime ScopedLog( TEXT("3.SharedSorting"), &CurrentShared ); FEventArraySorter::Sort( EventsShared, FEventGraphSample::GetEventPropertyByIndex(EEventPropertyIndex::InclusiveTimeMS).Name, EEventCompareOps::Less ); } } #endif // 0 }
void NUTUtil::SortUnitTestClassDefList(TArray<UUnitTest*>& InUnitTestClassDefaults) { // @todo #JohnBRefactorLambda: Convert these inline sort functions to lambda's now struct FUnitTestDateSort { FORCEINLINE bool operator()(const UUnitTest& A, const UUnitTest& B) const { return (A.GetUnitTestDate() < B.GetUnitTestDate()); } }; struct FUnitTestTypeDateSort { FUnitTestTypeDateSort(TArray<FString>& InTypeOrder) : TypeOrder(InTypeOrder) { } FORCEINLINE bool operator()(const UUnitTest& A, const UUnitTest& B) const { bool bReturnVal = false; if (TypeOrder.IndexOfByKey(A.GetUnitTestType()) < TypeOrder.IndexOfByKey(B.GetUnitTestType())) { bReturnVal = true; } else if (TypeOrder.IndexOfByKey(A.GetUnitTestType()) == TypeOrder.IndexOfByKey(B.GetUnitTestType()) && A.GetUnitTestDate() < B.GetUnitTestDate()) { bReturnVal = true; } return bReturnVal; } /** The order with which the prioritize types */ TArray<FString> TypeOrder; }; // First reorder the unit test classes by date, then grab the unit test types by date, then group them by type/date TArray<FString> ListTypes; InUnitTestClassDefaults.Sort(FUnitTestDateSort()); for (int i=0; i<InUnitTestClassDefaults.Num(); i++) { ListTypes.AddUnique(InUnitTestClassDefaults[i]->GetUnitTestType()); } // Now sort again, based both on type and date InUnitTestClassDefaults.Sort(FUnitTestTypeDateSort(ListTypes)); }
void FMacErrorReport::FindMostRecentErrorReports(TArray<FString>& ErrorReportPaths, const FTimespan& MaxCrashReportAge) { auto& PlatformFile = FPlatformFileManager::Get().GetPlatformFile(); FDateTime MinCreationTime = FDateTime::Now() - MaxCrashReportAge; auto ReportFinder = MakeDirectoryVisitor([&](const TCHAR* FilenameOrDirectory, bool bIsDirectory) { if (bIsDirectory) { auto TimeStamp = PlatformFile.GetTimeStamp(FilenameOrDirectory); if (TimeStamp > MinCreationTime) { ErrorReportPaths.Add(FilenameOrDirectory); } } return true; }); FString AllReportsDirectory = FPaths::GameAgnosticSavedDir() / TEXT("Crashes"); PlatformFile.IterateDirectory( *AllReportsDirectory, ReportFinder); ErrorReportPaths.Sort([&](const FString& L, const FString& R) { auto TimeStampL = PlatformFile.GetTimeStamp(*L); auto TimeStampR = PlatformFile.GetTimeStamp(*R); return TimeStampL > TimeStampR; }); }
void FSplineComponentVisualizer::OnDuplicateKey() { const FScopedTransaction Transaction(LOCTEXT("DuplicateSplinePoint", "Duplicate Spline Point")); USplineComponent* SplineComp = GetEditedSplineComponent(); check(SplineComp != nullptr); check(LastKeyIndexSelected != INDEX_NONE); check(SelectedKeys.Num() > 0); check(SelectedKeys.Contains(LastKeyIndexSelected)); SplineComp->Modify(); if (AActor* Owner = SplineComp->GetOwner()) { Owner->Modify(); } // Get a sorted list of all the selected indices, highest to lowest TArray<int32> SelectedKeysSorted; for (int32 SelectedKeyIndex : SelectedKeys) { SelectedKeysSorted.Add(SelectedKeyIndex); } SelectedKeysSorted.Sort([](int32 A, int32 B) { return A > B; }); // Insert duplicates into the list, highest index first, so that the lower indices remain the same FInterpCurveVector& SplineInfo = SplineComp->SplineInfo; FInterpCurveQuat& SplineRotInfo = SplineComp->SplineRotInfo; FInterpCurveVector& SplineScaleInfo = SplineComp->SplineScaleInfo; for (int32 SelectedKeyIndex : SelectedKeysSorted) { // Insert duplicates into arrays. // It's necessary to take a copy because copying existing array items by reference isn't allowed (the array may reallocate) SplineInfo.Points.Insert(FInterpCurvePoint<FVector>(SplineInfo.Points[SelectedKeyIndex]), SelectedKeyIndex); SplineRotInfo.Points.Insert(FInterpCurvePoint<FQuat>(SplineRotInfo.Points[SelectedKeyIndex]), SelectedKeyIndex); SplineScaleInfo.Points.Insert(FInterpCurvePoint<FVector>(SplineScaleInfo.Points[SelectedKeyIndex]), SelectedKeyIndex); } // Repopulate the selected keys SelectedKeys.Empty(); int32 Offset = SelectedKeysSorted.Num(); for (int32 SelectedKeyIndex : SelectedKeysSorted) { SelectedKeys.Add(SelectedKeyIndex + Offset); if (LastKeyIndexSelected == SelectedKeyIndex) { LastKeyIndexSelected += Offset; } Offset--; } // Unset tangent handle selection SelectedTangentHandle = INDEX_NONE; SelectedTangentHandleType = ESelectedTangentHandle::None; NotifyComponentModified(); // CachedRotation = SplineComp->GetQuaternionAtSplinePoint(LastKeyIndexSelected, ESplineCoordinateSpace::World); }
FString UGatherTextFromAssetsCommandlet::FDialogueHelper::ArrayMetaDataToString( const TArray< TSharedPtr< FLocMetadataValue > >& MetadataArray ) { FString FinalString; if( MetadataArray.Num() > 0 ) { TArray< FString > MetadataStrings; for( TSharedPtr< FLocMetadataValue > DataEntry : MetadataArray ) { if( DataEntry->Type == ELocMetadataType::String ) { MetadataStrings.Add(DataEntry->AsString()); } } MetadataStrings.Sort(); for( const FString& StrEntry : MetadataStrings ) { if(FinalString.Len()) { FinalString += TEXT(","); } FinalString += StrEntry; } } return FinalString; }
void UGISInventoryBaseComponent::PreLootAction(TArray<class AGISPickupActor*> PickupsIn) { TArray<FGISPickupActorDistanceHelper> HelperStruct; FVector PawmLocation = PCOwner->GetPawn()->GetActorLocation(); for (AGISPickupActor* Pickup : PickupsIn) { if (Pickup) { if (Pickup->ItemToLoot.Num() > 0) { float Distance = FVector::Dist(PawmLocation, Pickup->GetActorLocation()); FGISPickupActorDistanceHelper helper(Distance, Pickup); HelperStruct.Add(helper); } } } HelperStruct.Sort(); if (HelperStruct.IsValidIndex(0)) { //don't need to check everything. If closest actor is to far, rest is as well. if (HelperStruct[0].Distance > MaxLootingDistance) StartLooting(HelperStruct[0].PickupActor.Get()); } }
TSharedPtr< FLocMetadataValue > UGatherTextFromAssetsCommandlet::FDialogueHelper::GenSourceTargetMetadata( const FString& SpeakerName, const TArray< FString >& TargetNames, bool bCompact ) { /* This function can support two different formats. The first format is compact and results in string entries that will later be combined into something like this "Variations": [ "Jenny -> Audience", "Zak -> Audience" ] The second format is verbose and results in object entries that will later be combined into something like this "VariationsTest": [ { "Speaker": "Jenny", "Targets": [ "Audience" ] }, { "Speaker": "Zak", "Targets": [ "Audience" ] } ] */ TSharedPtr< FLocMetadataValue > Result; if( bCompact ) { TArray<FString> SortedTargetNames = TargetNames; SortedTargetNames.Sort(); FString TargetNamesString; for( const FString& StrEntry : SortedTargetNames ) { if(TargetNamesString.Len()) { TargetNamesString += TEXT(","); } TargetNamesString += StrEntry; } Result = MakeShareable( new FLocMetadataValueString( FString::Printf( TEXT("%s -> %s" ), *SpeakerName, *TargetNamesString ) ) ); } else { TArray< TSharedPtr< FLocMetadataValue > > TargetNamesMetadataList; for( const FString& StrEntry: TargetNames ) { TargetNamesMetadataList.Add( MakeShareable( new FLocMetadataValueString( StrEntry ) ) ); } TSharedPtr< FLocMetadataObject > MetadataObj = MakeShareable( new FLocMetadataObject() ); MetadataObj->SetStringField( PropertyName_Speaker, SpeakerName ); MetadataObj->SetArrayField( PropertyName_Targets, TargetNamesMetadataList ); Result = MakeShareable( new FLocMetadataValueObject( MetadataObj.ToSharedRef() ) ); } return Result; }
void FObjectMemoryAnalyzer::PrintResults(FOutputDevice& Ar, uint32 PrintFlags) { TArray<FObjectMemoryUsage> Results; GetResults(Results); Results.Sort(FCompareFSortBySize(ESortKey::InclusiveTotal)); Ar.Logf( TEXT("%-100s %-10s %-10s %-10s %-10s"), TEXT("Object"), TEXT("InclBytes"), TEXT("ExclBytes"), TEXT("InclResKBytes"), TEXT("ExclResKBytes") ); for( int32 i=0; i < Results.Num(); ++i ) { const FObjectMemoryUsage& Annotation = Results[i]; if (Annotation.IsRoot() || (Annotation.RootReferencer.Num() == 0 && Annotation.NonRootReferencer.Num() == 0) ) { Ar.Logf( TEXT("%-100s %-10d %-10d %-10d %-10d"), *FString::Printf(TEXT("%s %s"), *Annotation.Object->GetClass()->GetName(), *Annotation.Object->GetName()), (int32)Annotation.InclusiveMemoryUsage, (int32)Annotation.ExclusiveMemoryUsage, (int32)(Annotation.InclusiveResourceSize/1024), (int32)(Annotation.ExclusiveResourceSize/1024) ); if (!!(PrintFlags&EPrintFlags::PrintReferences)) { PrintSubObjects(Ar, TEXT(" -> "), Annotation.Object, PrintFlags); } } } }
EConvertQueryResult AddSweepResults(bool& OutHasValidBlockingHit, const UWorld* World, int32 NumHits, PxSweepHit* Hits, float CheckLength, const PxFilterData& QueryFilter, TArray<FHitResult>& OutHits, const FVector& StartLoc, const FVector& EndLoc, const PxGeometry& Geom, const PxTransform& QueryTM, float MaxDistance, bool bReturnFaceIndex, bool bReturnPhysMat) { OutHits.Reserve(OutHits.Num() + NumHits); EConvertQueryResult ConvertResult = EConvertQueryResult::Valid; bool bHadBlockingHit = false; const PxVec3 PDir = U2PVector((EndLoc - StartLoc).GetSafeNormal()); for(int32 i=0; i<NumHits; i++) { PxSweepHit& PHit = Hits[i]; checkSlow(PHit.flags & PxHitFlag::eDISTANCE); if(PHit.distance <= MaxDistance) { PHit.faceIndex = FindFaceIndex(PHit, PDir); FHitResult& NewResult = OutHits[OutHits.AddDefaulted()]; if (ConvertQueryImpactHit(World, PHit, NewResult, CheckLength, QueryFilter, StartLoc, EndLoc, &Geom, QueryTM, bReturnFaceIndex, bReturnPhysMat) == EConvertQueryResult::Valid) { bHadBlockingHit |= NewResult.bBlockingHit; } else { // Reject invalid result (this should be rare). Remove from the results. OutHits.Pop(/*bAllowShrinking=*/ false); ConvertResult = EConvertQueryResult::Invalid; } } } // Sort results from first to last hit OutHits.Sort( FCompareFHitResultTime() ); OutHasValidBlockingHit = bHadBlockingHit; return ConvertResult; }
void BuildResourceTableTokenStream(const TArray<uint32>& InResourceMap, int32 MaxBoundResourceTable, TArray<uint32>& OutTokenStream) { // First we sort the resource map. TArray<uint32> SortedResourceMap = InResourceMap; SortedResourceMap.Sort(); // The token stream begins with a table that contains offsets per bound uniform buffer. // This offset provides the start of the token stream. OutTokenStream.AddZeroed(MaxBoundResourceTable+1); auto LastBufferIndex = FRHIResourceTableEntry::GetEndOfStreamToken(); for (int32 i = 0; i < SortedResourceMap.Num(); ++i) { auto BufferIndex = FRHIResourceTableEntry::GetUniformBufferIndex(SortedResourceMap[i]); if (BufferIndex != LastBufferIndex) { // Store the offset for resources from this buffer. OutTokenStream[BufferIndex] = OutTokenStream.Num(); LastBufferIndex = BufferIndex; } OutTokenStream.Add(SortedResourceMap[i]); } // Add a token to mark the end of the stream. Not needed if there are no bound resources. if (OutTokenStream.Num()) { OutTokenStream.Add(FRHIResourceTableEntry::GetEndOfStreamToken()); } }
void FAnimTrack::CollapseAnimSegments() { if(AnimSegments.Num() > 0) { // Sort function struct FSortFloatInt { bool operator()( const TKeyValuePair<float, int32> &A, const TKeyValuePair<float, int32>&B ) const { return A.Key < B.Key; } }; // Create sorted map of start time to segment TArray<TKeyValuePair<float, int32>> m; for( int32 SegmentInd=0; SegmentInd < AnimSegments.Num(); ++SegmentInd ) { m.Add(TKeyValuePair<float, int32>(AnimSegments[SegmentInd].StartPos, SegmentInd)); } m.Sort(FSortFloatInt()); //collapse all start times based on sorted map FAnimSegment* PrevSegment = &AnimSegments[m[0].Value]; PrevSegment->StartPos = 0.0f; for ( int32 SegmentInd=1; SegmentInd < m.Num(); ++SegmentInd ) { FAnimSegment* CurrSegment = &AnimSegments[m[SegmentInd].Value]; CurrSegment->StartPos = PrevSegment->StartPos + PrevSegment->GetLength(); PrevSegment = CurrSegment; } } }
/** * Dumps capture stack trace summary to the passed in log. */ void FScriptStackTracker::DumpStackTraces( int32 StackThreshold, FOutputDevice& Ar ) { // Avoid distorting results while we log them. check( !bAvoidCapturing ); bAvoidCapturing = true; // Make a copy as sorting causes index mismatch with TMap otherwise. TArray<FCallStack> SortedCallStacks = CallStacks; // Compare function, sorting callstack by stack count in descending order. struct FCompareStackCount { FORCEINLINE bool operator()( const FCallStack& A, const FCallStack& B ) const { return B.StackCount < A.StackCount; } }; // Sort callstacks in descending order by stack count. SortedCallStacks.Sort( FCompareStackCount() ); // Iterate over each callstack to get total stack count. uint64 TotalStackCount = 0; for( int32 CallStackIndex=0; CallStackIndex<SortedCallStacks.Num(); CallStackIndex++ ) { const FCallStack& CallStack = SortedCallStacks[CallStackIndex]; TotalStackCount += CallStack.StackCount; } // Calculate the number of frames we captured. int32 FramesCaptured = 0; if( bIsEnabled ) { FramesCaptured = GFrameCounter - StartFrameCounter; } else { FramesCaptured = StopFrameCounter - StartFrameCounter; } // Log quick summary as we don't log each individual so totals in CSV won't represent real totals. Ar.Logf(TEXT("Captured %i unique callstacks totalling %i function calls over %i frames, averaging %5.2f calls/frame"), SortedCallStacks.Num(), (int32)TotalStackCount, FramesCaptured, (float) TotalStackCount / FramesCaptured); // Iterate over each callstack and write out info in human readable form in CSV format for( int32 CallStackIndex=0; CallStackIndex<SortedCallStacks.Num(); CallStackIndex++ ) { const FCallStack& CallStack = SortedCallStacks[CallStackIndex]; // Avoid log spam by only logging above threshold. if( CallStack.StackCount > StackThreshold ) { // First row is stack count. FString CallStackString = FString::FromInt((int32)CallStack.StackCount); CallStackString += LINE_TERMINATOR; CallStackString += CallStack.StackTrace; // Finally log with ',' prefix so "Log:" can easily be discarded as row in Excel. Ar.Logf(TEXT(",%s"),*CallStackString); } } // Done logging. bAvoidCapturing = false; }
bool UBlendSpaceBase::GetSamplesFromBlendInput(const FVector &BlendInput, TArray<FBlendSampleData> & OutSampleDataList) const { TArray<FGridBlendSample> RawGridSamples; GetRawSamplesFromBlendInput(BlendInput, RawGridSamples); OutSampleDataList.Empty(); // consolidate all samples for (int32 SampleNum=0; SampleNum<RawGridSamples.Num(); ++SampleNum) { FGridBlendSample& GridSample = RawGridSamples[SampleNum]; float GridWeight = GridSample.BlendWeight; FEditorElement& GridElement = GridSample.GridElement; for(int Ind = 0; Ind < GridElement.MAX_VERTICES; ++Ind) { if(GridElement.Indices[Ind] != INDEX_NONE) { int32 Index = OutSampleDataList.AddUnique(GridElement.Indices[Ind]); OutSampleDataList[Index].AddWeight(GridElement.Weights[Ind]*GridWeight); } } } /** Used to sort by Weight. */ struct FCompareFBlendSampleData { FORCEINLINE bool operator()( const FBlendSampleData& A, const FBlendSampleData& B ) const { return B.TotalWeight < A.TotalWeight; } }; OutSampleDataList.Sort( FCompareFBlendSampleData() ); // remove noisy ones int32 TotalSample = OutSampleDataList.Num(); float TotalWeight = 0.f; for (int32 I=0; I<TotalSample; ++I) { if (OutSampleDataList[I].TotalWeight < ZERO_ANIMWEIGHT_THRESH) { // cut anything in front of this OutSampleDataList.RemoveAt(I, TotalSample-I); break; } TotalWeight += OutSampleDataList[I].TotalWeight; } for (int32 I=0; I<OutSampleDataList.Num(); ++I) { // normalize to all weights OutSampleDataList[I].TotalWeight /= TotalWeight; } return (OutSampleDataList.Num()!=0); }
bool UBlendSpaceBase::GetSamplesFromBlendInput(const FVector &BlendInput, TArray<FBlendSampleData> & OutSampleDataList) const { static TArray<FGridBlendSample, TInlineAllocator<4> > RawGridSamples; check(IsInGameThread() && !RawGridSamples.Num()); // this must be called non-recursively from the gamethread GetRawSamplesFromBlendInput(BlendInput, RawGridSamples); OutSampleDataList.Reset(); OutSampleDataList.Reserve(RawGridSamples.Num() * FEditorElement::MAX_VERTICES); // consolidate all samples for (int32 SampleNum=0; SampleNum<RawGridSamples.Num(); ++SampleNum) { FGridBlendSample& GridSample = RawGridSamples[SampleNum]; float GridWeight = GridSample.BlendWeight; FEditorElement& GridElement = GridSample.GridElement; for(int Ind = 0; Ind < GridElement.MAX_VERTICES; ++Ind) { if(GridElement.Indices[Ind] != INDEX_NONE) { int32 Index = OutSampleDataList.AddUnique(GridElement.Indices[Ind]); OutSampleDataList[Index].AddWeight(GridElement.Weights[Ind]*GridWeight); } } } /** Used to sort by Weight. */ struct FCompareFBlendSampleData { FORCEINLINE bool operator()( const FBlendSampleData& A, const FBlendSampleData& B ) const { return B.TotalWeight < A.TotalWeight; } }; OutSampleDataList.Sort( FCompareFBlendSampleData() ); // remove noisy ones int32 TotalSample = OutSampleDataList.Num(); float TotalWeight = 0.f; for (int32 I=0; I<TotalSample; ++I) { if (OutSampleDataList[I].TotalWeight < ZERO_ANIMWEIGHT_THRESH) { // cut anything in front of this OutSampleDataList.RemoveAt(I, TotalSample-I, false); // we won't shrink here, that might screw up alloc optimization at a higher level, if not this is temp anyway break; } TotalWeight += OutSampleDataList[I].TotalWeight; } for (int32 I=0; I<OutSampleDataList.Num(); ++I) { // normalize to all weights OutSampleDataList[I].TotalWeight /= TotalWeight; } RawGridSamples.Reset(); return (OutSampleDataList.Num()!=0); }
virtual int32 GetFriendList(TArray< TSharedPtr<FFriendViewModel> >& OutFriendsList) override { TArray< TSharedPtr< IFriendItem > > FriendItemList = FriendsAndChatManager.Pin()->GetRecentPlayerList(); FriendItemList.Sort(FCompareGroupByName()); for(const auto& FriendItem : FriendItemList) { OutFriendsList.Add(FriendViewModelFactory->Create(FriendItem.ToSharedRef())); } return 0; }
bool UBehaviorTreeManager::LoadTree(UBehaviorTree& Asset, UBTCompositeNode*& Root, uint16& InstanceMemorySize) { SCOPE_CYCLE_COUNTER(STAT_AI_BehaviorTree_LoadTime); for (int32 TemplateIndex = 0; TemplateIndex < LoadedTemplates.Num(); TemplateIndex++) { FBehaviorTreeTemplateInfo& TemplateInfo = LoadedTemplates[TemplateIndex]; if (TemplateInfo.Asset == &Asset) { Root = TemplateInfo.Template; InstanceMemorySize = TemplateInfo.InstanceMemorySize; return true; } } if (Asset.RootNode) { FBehaviorTreeTemplateInfo TemplateInfo; TemplateInfo.Asset = &Asset; TemplateInfo.Template = Cast<UBTCompositeNode>(StaticDuplicateObject(Asset.RootNode, this, TEXT("None"))); TArray<FNodeInitializationData> InitList; uint16 ExecutionIndex = 0; InitializeNodeHelper(NULL, TemplateInfo.Template, 0, ExecutionIndex, InitList, Asset, this); #if USE_BEHAVIORTREE_DEBUGGER // fill in information about next nodes in execution index, before sorting memory offsets for (int32 Index = 0; Index < InitList.Num() - 1; Index++) { InitList[Index].Node->InitializeExecutionOrder(InitList[Index + 1].Node); } #endif // sort nodes by memory size, so they can be packed better // it still won't protect against structures, that are internally misaligned (-> uint8, uint32) // but since all Engine level nodes are good... InitList.Sort(FNodeInitializationData::FMemorySort()); uint16 MemoryOffset = 0; for (int32 Index = 0; Index < InitList.Num(); Index++) { InitList[Index].Node->InitializeNode(InitList[Index].ParentNode, InitList[Index].ExecutionIndex, InitList[Index].SpecialDataSize + MemoryOffset, InitList[Index].TreeDepth); MemoryOffset += InitList[Index].DataSize; } TemplateInfo.InstanceMemorySize = MemoryOffset; INC_DWORD_STAT(STAT_AI_BehaviorTree_NumTemplates); LoadedTemplates.Add(TemplateInfo); Root = TemplateInfo.Template; InstanceMemorySize = TemplateInfo.InstanceMemorySize; return true; } return false; }
int32 UPartyBeaconState::GetTeamAssignment(const FPartyReservation& Party) { if (NumTeams > 1) { TArray<FTeamBalanceInfo> PotentialTeamChoices; for (int32 TeamIdx = 0; TeamIdx < NumTeams; TeamIdx++) { const int32 CurrentPlayersOnTeam = GetNumPlayersOnTeam(TeamIdx); if ((CurrentPlayersOnTeam + Party.PartyMembers.Num()) <= NumPlayersPerTeam) { new (PotentialTeamChoices)FTeamBalanceInfo(TeamIdx, CurrentPlayersOnTeam); } } // Grab one from our list of choices if (PotentialTeamChoices.Num() > 0) { if (TeamAssignmentMethod == ETeamAssignmentMethod::Smallest) { PotentialTeamChoices.Sort(FSortTeamSizeSmallestToLargest()); return PotentialTeamChoices[0].TeamIdx; } else if (TeamAssignmentMethod == ETeamAssignmentMethod::BestFit) { PotentialTeamChoices.Sort(FSortTeamSizeSmallestToLargest()); return PotentialTeamChoices[PotentialTeamChoices.Num() - 1].TeamIdx; } else if (TeamAssignmentMethod == ETeamAssignmentMethod::Random) { int32 TeamIndex = FMath::Rand() % PotentialTeamChoices.Num(); return PotentialTeamChoices[TeamIndex].TeamIdx; } } else { UE_LOG(LogBeacon, Warning, TEXT("UPartyBeaconHost::GetTeamAssignment: couldn't find an open team for party members.")); return INDEX_NONE; } } return ForceTeamNum; }
bool ScanPackages(TArray<FileInfo>& info, IProgressCallback* progress) { info.Empty(); ScanPackageData data; data.PkgInfo = &info; data.Progress = progress; appEnumGameFiles(ScanPackage, data); info.Sort(InfoCmp); return !data.Cancelled; }
void USignificanceManager::GetManagedObjects(TArray<const USignificanceManager::FManagedObjectInfo*>& OutManagedObjects, bool bInSignificanceOrder) const { OutManagedObjects.Reserve(ManagedObjects.Num()); for (const TPair<FName, TArray<const FManagedObjectInfo*>>& TagToObjectInfoArrayPair : ManagedObjectsByTag) { OutManagedObjects.Append(TagToObjectInfoArrayPair.Value); } if (bInSignificanceOrder) { OutManagedObjects.Sort(PickCompareBySignificance(bSortSignificanceAscending)); } }
static void SortCategoriesRecursively( TArray< FPluginCategoryTreeItemPtr >& Categories ) { // Sort the categories Categories.Sort( FPluginCategoryTreeItemSorter() ); // Sort sub-categories for( auto SubCategoryIt( Categories.CreateConstIterator() ); SubCategoryIt; ++SubCategoryIt ) { const auto& SubCategory = *SubCategoryIt; SortCategoriesRecursively( SubCategory->AccessSubCategories() ); } }
void FDetailLayoutBuilderImpl::GenerateDetailLayout() { AllRootTreeNodes.Empty(); // Sort by the order in which categories were edited struct FCompareFDetailCategoryImpl { FORCEINLINE bool operator()( TSharedPtr<FDetailCategoryImpl> A, TSharedPtr<FDetailCategoryImpl> B ) const { return A->GetSortOrder() < B->GetSortOrder(); } }; // Merge the two category lists and sort them based on priority FCategoryMap AllCategories = CustomCategoryMap; AllCategories.Append( DefaultCategoryMap ); TArray< TSharedRef<FDetailCategoryImpl> > SimpleCategories; TArray< TSharedRef<FDetailCategoryImpl> > AdvancedOnlyCategories; BuildCategories( CustomCategoryMap, SimpleCategories, AdvancedOnlyCategories ); BuildCategories( DefaultCategoryMap, SimpleCategories, AdvancedOnlyCategories ); SimpleCategories.Sort( FCompareFDetailCategoryImpl() ); AdvancedOnlyCategories.Sort( FCompareFDetailCategoryImpl() ); /** Merge the two category lists in sorted order */ for( int32 CategoryIndex = 0; CategoryIndex < SimpleCategories.Num(); ++CategoryIndex ) { AllRootTreeNodes.Add( SimpleCategories[CategoryIndex] ); } for( int32 CategoryIndex = 0; CategoryIndex < AdvancedOnlyCategories.Num(); ++CategoryIndex ) { AllRootTreeNodes.Add( AdvancedOnlyCategories[CategoryIndex] ); } }
void USkeleton::RemoveBonesFromSkeleton( const TArray<FName>& BonesToRemove, bool bRemoveChildBones ) { TArray<int32> BonesRemoved = ReferenceSkeleton.RemoveBonesByName(BonesToRemove); if(BonesRemoved.Num() > 0) { BonesRemoved.Sort(); for(int32 Index = BonesRemoved.Num()-1; Index >=0; --Index) { BoneTree.RemoveAt(Index); } HandleSkeletonHierarchyChange(); } }
void FGameplayCueTranslationManager::RefreshNameSwaps() { AllNameSwaps.Reset(); TArray<UGameplayCueTranslator*> CDOList; // Gather CDOs for( TObjectIterator<UClass> It ; It ; ++It ) { UClass* Class = *It; if( !Class->HasAnyClassFlags(CLASS_Abstract | CLASS_Deprecated) ) { if( Class->IsChildOf(UGameplayCueTranslator::StaticClass()) ) { UGameplayCueTranslator* CDO = Class->GetDefaultObject<UGameplayCueTranslator>(); if (CDO->IsEnabled()) { CDOList.Add(CDO); } } } } // Sort and get translated names CDOList.Sort([](const UGameplayCueTranslator& A, const UGameplayCueTranslator& B) { return (A.GetPriority() > B.GetPriority()); }); for (UGameplayCueTranslator* CDO : CDOList) { FNameSwapData& Data = AllNameSwaps[AllNameSwaps.AddDefaulted()]; CDO->GetTranslationNameSpawns(Data.NameSwaps); if (Data.NameSwaps.Num() > 0) { Data.ClassCDO = CDO; } else { AllNameSwaps.Pop(false); } } #if WITH_EDITOR // Give UniqueID to each rule int32 ID=1; for (FNameSwapData& GroupData : AllNameSwaps) { for (FGameplayCueTranslationNameSwap& SwapData : GroupData.NameSwaps) { SwapData.EditorData.UniqueID = ID++; } } #endif }
void FCollectionContextMenu::MakeSaveDynamicCollectionSubMenu(FMenuBuilder& MenuBuilder, FText InSearchQuery) { auto OnCollectionCreated = FCollectionItem::FCollectionCreatedEvent::CreateSP(this, &FCollectionContextMenu::ExecuteSaveDynamicCollection, InSearchQuery); // Create new root level collection MakeNewCollectionSubMenu(MenuBuilder, ECollectionStorageMode::Dynamic, SCollectionView::FCreateCollectionPayload(OnCollectionCreated)); FCollectionManagerModule& CollectionManagerModule = FCollectionManagerModule::GetModule(); TArray<FCollectionNameType> AvailableCollections; CollectionManagerModule.Get().GetCollections(AvailableCollections); AvailableCollections.Sort([](const FCollectionNameType& One, const FCollectionNameType& Two) -> bool { return One.Name < Two.Name; }); if (AvailableCollections.Num() > 0) { MenuBuilder.BeginSection("CollectionReplaceCollection", LOCTEXT("OverwriteDynamicCollectionMenuHeading", "Overwrite Dynamic Collection")); for (const FCollectionNameType& AvailableCollection : AvailableCollections) { // Never display system collections if (AvailableCollection.Type == ECollectionShareType::CST_System) { continue; } // Can only overwrite dynamic collections ECollectionStorageMode::Type StorageMode = ECollectionStorageMode::Static; CollectionManagerModule.Get().GetCollectionStorageMode(AvailableCollection.Name, AvailableCollection.Type, StorageMode); if (StorageMode != ECollectionStorageMode::Dynamic) { continue; } MenuBuilder.AddMenuEntry( FText::FromName(AvailableCollection.Name), FText::Format(LOCTEXT("SaveDynamicCollection_OverwriteExistingCollectionToolTip", "Overwrite '{0}' with the current search query"), FText::FromName(AvailableCollection.Name)), FSlateIcon(FEditorStyle::GetStyleSetName(), ECollectionShareType::GetIconStyleName(AvailableCollection.Type)), FUIAction( FExecuteAction::CreateSP( this, &FCollectionContextMenu::ExecuteSaveDynamicCollection, AvailableCollection, InSearchQuery ), FCanExecuteAction::CreateSP( this, &FCollectionContextMenu::CanExecuteSaveDynamicCollection, AvailableCollection ) ) ); } MenuBuilder.EndSection(); } }
AEyeXActorBase* AEyeXPlayerController::FindByBoxedLineTrace(FHitResult& OutHit, const FSceneView* const View, const FVector2D& GazePoint, const FCollisionObjectQueryParams& ObjectParams, const FCollisionQueryParams& TraceParams) { UWorld* World = GetWorld(); if (!World) return nullptr; // Set up a box around the gaze point FVector2D Corners[4]; GetBoxCorners(GazePoint, BoxSize * GetApproximatePixelsPerMillimeter(), Corners); // First check center point AEyeXActorBase* EyeXActor = nullptr; FVector Start, End; FEyeXUtils::GetStartAndEndOfLineTrace(View, MaxDistance, GazePoint, /*out*/ Start, /*out*/ End); if (World->LineTraceSingleByObjectType(OutHit, Start, End, ObjectParams, TraceParams)) { EyeXActor = Cast<AEyeXActorBase>(OutHit.GetActor()); } else { // If center point missed we perform traces in a box around the gaze point // and choose the closest EyeXActor hit by the traces TArray<AEyeXActorBase*> EyeXActors; for (int i = 0; i < 4; ++i) { FVector BoxStart, BoxEnd; FEyeXUtils::GetStartAndEndOfLineTrace(View, MaxDistance, Corners[i], /*out*/ BoxStart, /*out*/ BoxEnd); if (World->LineTraceSingleByObjectType(OutHit, BoxStart, BoxEnd, ObjectParams, TraceParams)) { AEyeXActorBase* Actor = Cast<AEyeXActorBase>(OutHit.GetActor()); if (!Actor) continue; EyeXActors.Add(Actor); } VisualizeHitTestPoint(bVisualizeDetection, World, BoxStart); } if (EyeXActors.Num() > 0) { FEyeXUtils::ActorDistanceComparer Comparer(PlayerCameraManager); EyeXActors.Sort(Comparer); EyeXActor = EyeXActors[0]; } } VisualizeHit(bVisualizeDetection, World, OutHit); VisualizeGazePoint(bVisualizeDetection, World, Start); return EyeXActor; }
TArray<FEditorModeInfo> FEditorModeRegistry::GetSortedModeInfo() const { TArray<FEditorModeInfo> ModeInfoArray; for (const auto& Pair : ModeFactories) { ModeInfoArray.Add(Pair.Value->GetModeInfo()); } ModeInfoArray.Sort([](const FEditorModeInfo& A, const FEditorModeInfo& B){ return A.PriorityOrder < B.PriorityOrder; }); return ModeInfoArray; }
FRectangleSortHelper(TArray<FIntRect>& InOutSprites) { // Sort by Y, then by X (top left corner), descending order (so we can use it as a stack from the top row down) TArray<FIntRect> SpritesLeft = InOutSprites; SpritesLeft.Sort([](const FIntRect& A, const FIntRect& B) { return (A.Min.Y == B.Min.Y) ? (A.Min.X > B.Min.X) : (A.Min.Y > B.Min.Y); }); InOutSprites.Reset(); // Start pulling sprites out, the first one in each row will dominate remaining ones and cause them to get labeled TArray<FIntRect> DominatedSprites; DominatedSprites.Empty(SpritesLeft.Num()); while (SpritesLeft.Num()) { FIntRect DominatingSprite = SpritesLeft.Pop(); DominatedSprites.Add(DominatingSprite); // Find the sprites that are dominated (intersect the infinite horizontal band described by the dominating sprite) for (int32 Index = 0; Index < SpritesLeft.Num();) { const FIntRect& CurElement = SpritesLeft[Index]; if ((CurElement.Min.Y <= DominatingSprite.Max.Y) && (CurElement.Max.Y >= DominatingSprite.Min.Y)) { DominatedSprites.Add(CurElement); SpritesLeft.RemoveAt(Index, /*Count=*/ 1, /*bAllowShrinking=*/ false); } else { ++Index; } } // Sort the sprites in the band by X and add them to the result DominatedSprites.Sort([](const FIntRect& A, const FIntRect& B) { return (A.Min.X < B.Min.X); }); InOutSprites.Append(DominatedSprites); DominatedSprites.Reset(); } }