本文整理汇总了C++中TSet类的典型用法代码示例。如果您正苦于以下问题:C++ TSet类的具体用法?C++ TSet怎么用?C++ TSet使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了TSet类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: UE_LOG
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;
}
示例2: GenerateDuplicatedLayerName
FText STileLayerList::GenerateDuplicatedLayerName(const FString& InputNameRaw, UPaperTileMap* TileMap)
{
// Create a set of existing names
TSet<FString> ExistingNames;
for (UPaperTileLayer* ExistingLayer : TileMap->TileLayers)
{
ExistingNames.Add(ExistingLayer->LayerName.ToString());
}
FString BaseName = InputNameRaw;
int32 TestIndex = 0;
bool bAddNumber = false;
// See if this is the result of a previous duplication operation, and change the desired name accordingly
int32 SpaceIndex;
if (InputNameRaw.FindLastChar(' ', /*out*/ SpaceIndex))
{
FString PossibleDuplicationSuffix = InputNameRaw.Mid(SpaceIndex + 1);
if (PossibleDuplicationSuffix == TEXT("copy"))
{
bAddNumber = true;
BaseName = InputNameRaw.Left(SpaceIndex);
TestIndex = 2;
}
else
{
int32 ExistingIndex = FCString::Atoi(*PossibleDuplicationSuffix);
const FString TestSuffix = FString::Printf(TEXT(" copy %d"), ExistingIndex);
if (InputNameRaw.EndsWith(TestSuffix))
{
bAddNumber = true;
BaseName = InputNameRaw.Left(InputNameRaw.Len() - TestSuffix.Len());
TestIndex = ExistingIndex + 1;
}
}
}
// Find a good name
FString TestLayerName = BaseName + TEXT(" copy");
if (bAddNumber || ExistingNames.Contains(TestLayerName))
{
do
{
TestLayerName = FString::Printf(TEXT("%s copy %d"), *BaseName, TestIndex++);
} while (ExistingNames.Contains(TestLayerName));
}
return FText::FromString(TestLayerName);
}
示例3: ParseFramesFromSpriteHash
static bool ParseFramesFromSpriteHash(TSharedPtr<FJsonObject> ObjectBlock, TArray<FSpriteFrame>& OutSpriteFrames, TSet<FName>& FrameNames)
{
GWarn->BeginSlowTask(NSLOCTEXT("Paper2D", "PaperJsonImporterFactory_ParsingSprites", "Parsing Sprite Frame"), true, true);
bool bLoadedSuccessfully = true;
// Parse all of the frames
int32 FrameCount = 0;
for (auto FrameIt = ObjectBlock->Values.CreateIterator(); FrameIt; ++FrameIt)
{
GWarn->StatusUpdate(FrameCount, ObjectBlock->Values.Num(), NSLOCTEXT("Paper2D", "PaperJsonImporterFactory_ParsingSprites", "Parsing Sprite Frames"));
bool bReadFrameSuccessfully = true;
FSpriteFrame Frame;
Frame.FrameName = *FrameIt.Key();
if (FrameNames.Contains(Frame.FrameName))
{
bReadFrameSuccessfully = false;
}
else
{
FrameNames.Add(Frame.FrameName);
}
TSharedPtr<FJsonValue> FrameDataAsValue = FrameIt.Value();
TSharedPtr<FJsonObject> FrameData;
if (FrameDataAsValue->Type == EJson::Object)
{
FrameData = FrameDataAsValue->AsObject();
bReadFrameSuccessfully = bReadFrameSuccessfully && ParseFrame(FrameData, /*out*/Frame);
}
else
{
bReadFrameSuccessfully = false;
}
if (bReadFrameSuccessfully)
{
OutSpriteFrames.Add(Frame);
}
else
{
UE_LOG(LogPaperSpriteSheetImporter, Warning, TEXT("Frame %s is in an unexpected format"), *Frame.FrameName.ToString());
bLoadedSuccessfully = false;
}
FrameCount++;
}
GWarn->EndSlowTask();
return bLoadedSuccessfully;
}
示例4: ToSlateTextureData
FSlateTextureDataPtr FTileThumbnail::UpdateThumbnail()
{
// No need images for persistent and always loaded levels
if (TileModel.IsPersistent())
{
return ToSlateTextureData(nullptr);
}
// Load image from a package header
if (!TileModel.IsVisible() || TileModel.IsSimulating())
{
const FName LevelAssetName = TileModel.GetAssetName();
TSet<FName> ObjectFullNames;
ObjectFullNames.Add(LevelAssetName);
FThumbnailMap ThumbnailMap;
if (ThumbnailTools::ConditionallyLoadThumbnailsFromPackage(TileModel.GetPackageFileName(), ObjectFullNames, ThumbnailMap))
{
const FObjectThumbnail* ObjectThumbnail = ThumbnailMap.Find(LevelAssetName);
return ToSlateTextureData(ObjectThumbnail);
}
}
// Render image from a visible level
else
{
ULevel* TargetLevel = TileModel.GetLevelObject();
if (TargetLevel)
{
FIntPoint RTSize = ThumbnailRenderTarget->GetSizeXY();
// Set persistent world package as transient to avoid package dirtying during thumbnail rendering
FUnmodifiableObject ImmuneWorld(TargetLevel->OwningWorld);
FObjectThumbnail NewThumbnail;
// Generate the thumbnail
ThumbnailTools::RenderThumbnail(
TargetLevel,
RTSize.X,
RTSize.Y,
ThumbnailTools::EThumbnailTextureFlushMode::NeverFlush,
ThumbnailRenderTarget,
&NewThumbnail
);
UPackage* MyOutermostPackage = CastChecked<UPackage>(TargetLevel->GetOutermost());
ThumbnailTools::CacheThumbnail(TileModel.GetAssetName().ToString(), &NewThumbnail, MyOutermostPackage);
return ToSlateTextureData(&NewThumbnail);
}
}
return ToSlateTextureData(nullptr);
}
示例5: FindChildGeometry
FGeometry SWidget::FindChildGeometry( const FGeometry& MyGeometry, TSharedRef<SWidget> WidgetToFind ) const
{
// We just need to find the one WidgetToFind among our descendants.
TSet< TSharedRef<SWidget> > WidgetsToFind;
{
WidgetsToFind.Add( WidgetToFind );
}
TMap<TSharedRef<SWidget>, FArrangedWidget> Result;
FindChildGeometries( MyGeometry, WidgetsToFind, Result );
return Result.FindChecked( WidgetToFind ).Geometry;
}
示例6: CompileOneBlueprint
void UKismetUpdateCommandlet::CompileOneBlueprint(UBlueprint* Blueprint)
{
FString PathName = Blueprint->GetPathName();
if (!AlreadyCompiledFullPaths.Contains(PathName))
{
// Make sure any referenced interfaces are already recompiled
for (int32 i = 0; i < Blueprint->ImplementedInterfaces.Num(); ++i)
{
const FBPInterfaceDescription& InterfaceDesc = Blueprint->ImplementedInterfaces[i];
if (UBlueprint* InterfaceBP = Cast<UBlueprint>(InterfaceDesc.Interface->ClassGeneratedBy))
{
CompileOneBlueprint(InterfaceBP);
}
}
// Make sure any referenced macros are already recompiled
{
// Find all macro instances
TArray<UK2Node_MacroInstance*> MacroNodes;
FBlueprintEditorUtils::GetAllNodesOfClass<UK2Node_MacroInstance>(Blueprint, /*out*/ MacroNodes);
// Find all unique macro blueprints that contributed to the used macro instances
TSet<UBlueprint*> UniqueMacroBlueprints;
for (int32 i = 0; i < MacroNodes.Num(); ++i)
{
UBlueprint* MacroBP = FBlueprintEditorUtils::FindBlueprintForGraphChecked(MacroNodes[i]->GetMacroGraph());
UniqueMacroBlueprints.Add(MacroBP);
}
// Compile each of the unique macro libraries
for (TSet<UBlueprint*>::TIterator It(UniqueMacroBlueprints); It; ++It)
{
UBlueprint* MacroBP = *It;
CompileOneBlueprint(MacroBP);
}
}
// Refresh and compile this blueprint
FBlueprintEditorUtils::RefreshAllNodes(Blueprint);
const bool bIsRegeneratingOnLoad = true;
FKismetEditorUtilities::CompileBlueprint(Blueprint, bIsRegeneratingOnLoad);
// Notify the user of errors
if (Blueprint->Status == BS_Error)
{
UE_LOG(LogBlueprintUpdateCommandlet, Warning, TEXT("[REPORT] Error: Failed to compile blueprint '%s'"), *Blueprint->GetName());
}
}
}
示例7: ResolveCircularDependenciesInnerFast
void FPackageDependencyInfo::ResolveCircularDependenciesInnerFast()
{
int32 NumReResolves = 0;
// We have a list of all packages the current package depends on.
// And we iterate through the list as long as we won't update any package info.
TSet<FPackageDependencyTrackingInfo*> ToBeProcessed;
// Find packages that matters.
for( auto ResolveIt = AllPackages.CreateIterator(); ResolveIt; ++ResolveIt )
{
FPackageDependencyTrackingInfo* PkgInfo = *ResolveIt;
if( PkgInfo && PkgInfo->DependentPackages.Num() )
{
ToBeProcessed.Add( PkgInfo );
}
}
do
{
NumReResolves = 0;
// Iterate through all valid packages.
for( auto ResolveIt = ToBeProcessed.CreateIterator(); ResolveIt; ++ResolveIt )
{
const int32 PackageIndex = 0;
FPackageDependencyTrackingInfo* InPkgInfo = *ResolveIt;
// Iterate through all dependent packages and update time if necessary.
for( auto DepPkgIt = InPkgInfo->DependentPackages.CreateIterator(); DepPkgIt; ++DepPkgIt )
{
NumResolveIterations++;
FPackageDependencyTrackingInfo* DepPkgInfo = DepPkgIt.Value();
if( DepPkgInfo != NULL )
{
if( InPkgInfo->DependentTimeStamp < DepPkgInfo->DependentTimeStamp )
{
InPkgInfo->DependentTimeStamp = DepPkgInfo->DependentTimeStamp;
ResolvedCircularDependencies.Add(InPkgInfo);
NumCirculars++;
// We updated a timestamp, so we need to run the iteration once again to make sure that other packages will be updated as well.
NumReResolves++;
}
}
}
}
NumResolvePasses++;
}
while( NumReResolves > 0 );
}
示例8: ToggleColumnForProperty
void FPropertyEditorToolkit::ToggleColumnForProperty( const TSharedPtr< FPropertyPath >& PropertyPath )
{
if ( !PropertyPath.IsValid() )
{
return;
}
TSharedRef< FPropertyPath > NewPath = PropertyPath->TrimRoot( PropertyTable->GetRootPath()->GetNumProperties() );
const TSet< TSharedRef< IPropertyTableRow > > SelectedRows = PropertyTable->GetSelectedRows();
for( auto RowIter = SelectedRows.CreateConstIterator(); RowIter; ++RowIter )
{
NewPath = NewPath->TrimRoot( (*RowIter)->GetPartialPath()->GetNumProperties() );
break;
}
if ( NewPath->GetNumProperties() == 0 )
{
return;
}
TSharedPtr< IPropertyTableColumn > ExistingColumn;
for( auto ColumnIter = PropertyTable->GetColumns().CreateConstIterator(); ColumnIter; ++ColumnIter )
{
TSharedRef< IPropertyTableColumn > Column = *ColumnIter;
const TSharedPtr< FPropertyPath > Path = Column->GetDataSource()->AsPropertyPath();
if ( Path.IsValid() && FPropertyPath::AreEqual( Path.ToSharedRef(), NewPath ) )
{
ExistingColumn = Column;
}
}
if ( ExistingColumn.IsValid() )
{
PropertyTable->RemoveColumn( ExistingColumn.ToSharedRef() );
const TSharedRef< FPropertyPath > ColumnPath = ExistingColumn->GetDataSource()->AsPropertyPath().ToSharedRef();
for (int Index = PropertyPathsAddedAsColumns.Num() - 1; Index >= 0 ; Index--)
{
if ( FPropertyPath::AreEqual( ColumnPath, PropertyPathsAddedAsColumns[ Index ] ) )
{
PropertyPathsAddedAsColumns.RemoveAt( Index );
}
}
}
else
{
PropertyTable->AddColumn( NewPath );
PropertyPathsAddedAsColumns.Add( NewPath );
}
}
示例9: RemoveOrphanedNodes
void UEnvironmentQueryGraph::RemoveOrphanedNodes()
{
UEnvQuery* QueryAsset = CastChecked<UEnvQuery>(GetOuter());
// Obtain a list of all nodes that should be in the asset
TSet<UObject*> AllNodes;
for (int32 Index = 0; Index < Nodes.Num(); ++Index)
{
UEnvironmentQueryGraphNode_Option* OptionNode = Cast<UEnvironmentQueryGraphNode_Option>(Nodes[Index]);
if (OptionNode)
{
UEnvQueryOption* OptionInstance = Cast<UEnvQueryOption>(OptionNode->NodeInstance);
if (OptionInstance)
{
AllNodes.Add(OptionInstance);
if (OptionInstance->Generator)
{
AllNodes.Add(OptionInstance->Generator);
}
}
for (int32 SubIdx = 0; SubIdx < OptionNode->Tests.Num(); SubIdx++)
{
if (OptionNode->Tests[SubIdx] && OptionNode->Tests[SubIdx]->NodeInstance)
{
AllNodes.Add(OptionNode->Tests[SubIdx]->NodeInstance);
}
}
}
}
// Obtain a list of all nodes actually in the asset and discard unused nodes
TArray<UObject*> AllInners;
const bool bIncludeNestedObjects = false;
GetObjectsWithOuter(QueryAsset, AllInners, bIncludeNestedObjects);
for (auto InnerIt = AllInners.CreateConstIterator(); InnerIt; ++InnerIt)
{
UObject* Node = *InnerIt;
const bool bEQSNode =
Node->IsA(UEnvQueryGenerator::StaticClass()) ||
Node->IsA(UEnvQueryTest::StaticClass()) ||
Node->IsA(UEnvQueryOption::StaticClass());
if (bEQSNode && !AllNodes.Contains(Node))
{
Node->SetFlags(RF_Transient);
Node->Rename(NULL, GetTransientPackage(), REN_DontCreateRedirectors | REN_NonTransactional | REN_ForceNoResetLoaders);
}
}
}
示例10: FixupPackageDependenciesForChunks
bool FChunkManifestGenerator::SaveManifests(FSandboxPlatformFile* InSandboxFile)
{
// Always do package dependency work, is required to modify asset registry
FixupPackageDependenciesForChunks(InSandboxFile);
if (bGenerateChunks)
{
for (auto Platform : Platforms)
{
if (!GenerateStreamingInstallManifest(Platform->PlatformName()))
{
return false;
}
// Generate map for the platform abstraction
TMultiMap<FString, int32> ChunkMap; // asset -> ChunkIDs map
TSet<int32> ChunkIDsInUse;
const FString PlatformName = Platform->PlatformName();
// Collect all unique chunk indices and map all files to their chunks
for (int32 ChunkIndex = 0; ChunkIndex < FinalChunkManifests.Num(); ++ChunkIndex)
{
if (FinalChunkManifests[ChunkIndex] && FinalChunkManifests[ChunkIndex]->Num())
{
ChunkIDsInUse.Add(ChunkIndex);
for (auto& Filename : *FinalChunkManifests[ChunkIndex])
{
FString PlatFilename = Filename.Value.Replace(TEXT("[Platform]"), *PlatformName);
ChunkMap.Add(PlatFilename, ChunkIndex);
}
}
}
// Sort our chunk IDs and file paths
ChunkMap.KeySort(TLess<FString>());
ChunkIDsInUse.Sort(TLess<int32>());
// Platform abstraction will generate any required platform-specific files for the chunks
if (!Platform->GenerateStreamingInstallManifest(ChunkMap, ChunkIDsInUse))
{
return false;
}
}
GenerateAssetChunkInformationCSV(FPaths::Combine(*FPaths::GameLogDir(), TEXT("ChunkLists")));
}
return true;
}
示例11: RefreshInstanceMap
void FMovieSceneSequenceInstance::RefreshInstanceMap( const TArray<UMovieSceneTrack*>& Tracks, const TArray<TWeakObjectPtr<UObject>>& RuntimeObjects, FMovieSceneInstanceMap& TrackInstances, IMovieScenePlayer& Player )
{
// All the tracks we found during this pass
TSet< UMovieSceneTrack* > FoundTracks;
// For every track, check if it has an instance, if not create one, otherwise refresh that instance
for( int32 TrackIndex = 0; TrackIndex < Tracks.Num(); ++TrackIndex )
{
UMovieSceneTrack* Track = Tracks[TrackIndex];
// A new track has been encountered
FoundTracks.Add( Track );
// See if the track has an instance
TSharedPtr<IMovieSceneTrackInstance> Instance = TrackInstances.FindRef( Track );
if ( !Instance.IsValid() )
{
// The track does not have an instance, create one
Instance = Track->CreateInstance();
Instance->RefreshInstance( RuntimeObjects, Player, *this );
Instance->SaveState(RuntimeObjects, Player, *this);
TrackInstances.Add( Track, Instance );
}
else
{
// The track has an instance, refresh it
Instance->RefreshInstance( RuntimeObjects, Player, *this );
Instance->SaveState(RuntimeObjects, Player, *this);
}
}
// Remove entries which no longer have a track associated with them
FMovieSceneInstanceMap::TIterator It = TrackInstances.CreateIterator();
for( ; It; ++It )
{
if( !FoundTracks.Contains( It.Key().Get() ) )
{
It.Value()->ClearInstance( Player, *this );
// This track was not found in the moviescene's track list so it was removed.
It.RemoveCurrent();
}
}
// Sort based on evaluation order
TrackInstances.ValueSort(FTrackInstanceEvalSorter());
}
示例12: GetParameterNames
void UMovieSceneParameterSection::GetParameterNames( TSet<FName>& ParameterNames ) const
{
for ( const FScalarParameterNameAndCurve& ScalarParameterNameAndCurve : ScalarParameterNamesAndCurves )
{
ParameterNames.Add( ScalarParameterNameAndCurve.ParameterName );
}
for ( const FVectorParameterNameAndCurves& VectorParameterNameAndCurves : VectorParameterNamesAndCurves )
{
ParameterNames.Add( VectorParameterNameAndCurves.ParameterName );
}
for ( const FColorParameterNameAndCurves& ColorParameterNameAndCurves : ColorParameterNamesAndCurves )
{
ParameterNames.Add( ColorParameterNameAndCurves.ParameterName );
}
}
示例13: GetAllCurves
void FTimeline::GetAllCurves(TSet<class UCurveBase*>& InOutCurves) const
{
for (auto& Track : InterpVectors)
{
InOutCurves.Add(Track.VectorCurve);
}
for (auto& Track : InterpFloats)
{
InOutCurves.Add(Track.FloatCurve);
}
for (auto& Track : InterpLinearColors)
{
InOutCurves.Add(Track.LinearColorCurve);
}
}
示例14: ReadCD
TVector<TColumn> ReadCD(const TString& fileName, const TCdParserDefaults& defaults) {
CB_ENSURE(NFs::Exists(TString(fileName)), "column description file is not found");
int columnsCount = defaults.UseDefaultType ? defaults.ColumnCount : 0;
TVector<TColumn> columns(columnsCount, TColumn{defaults.DefaultColumnType, TString()});
TSet<int> parsedColumns;
TString line;
TIFStream reader(fileName.c_str());
while (reader.ReadLine(line)) {
TVector<TString> tokens;
try {
Split(line, "\t", tokens);
} catch (const yexception& e) {
MATRIXNET_DEBUG_LOG << "Got exception " << e.what() << " while parsing feature descriptions line " << line << Endl;
break;
}
if (tokens.empty()) {
continue;
}
CB_ENSURE(tokens.ysize() == 2 || tokens.ysize() == 3, "Each line should have two or three columns. " << line);
int index = FromString<int>(tokens[0]);
CB_ENSURE(index >= 0, "Invalid column index " << index);
if (defaults.UseDefaultType) {
CB_ENSURE(index < columnsCount, "Invalid column index " << index);
}
CB_ENSURE(!parsedColumns.has(index), "column specified twice in cd file: " << index);
parsedColumns.insert(index);
columns.resize(Max(columns.ysize(), index + 1));
TStringBuf type = tokens[1];
if (type == "QueryId") {
type = "GroupId";
}
if (type == "Target") {
type = "Label";
}
CB_ENSURE(TryFromString<EColumn>(type, columns[index].Type), "unsupported column type " << type);
if (tokens.ysize() == 3) {
columns[index].Id = tokens[2];
}
}
if (!defaults.UseDefaultType) {
CheckAllFeaturesPresent(columns, parsedColumns);
}
return columns;
}
示例15: world
/*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;
}