Agrarsense
Public Member Functions | Protected Member Functions | Private Attributes | List of all members
ATagger Class Reference

#include <Tagger.h>

Inheritance diagram for ATagger:
Inheritance graph
[legend]
Collaboration diagram for ATagger:
Collaboration graph
[legend]

Public Member Functions

 ATagger ()
 
void ExportObjectLocationsToCSV ()
 
AActor * GetActorByInstanceID (float InstanceID)
 

Protected Member Functions

virtual void BeginPlay () override
 
virtual void EndPlay (const EEndPlayReason::Type EndPlayReason) override
 
void CreateCSVFile ()
 
void TagExistingActors ()
 
void OnActorSpawned (AActor *Actor)
 
void TagActor (AActor &Actor)
 
void WriteComponentToCSV (const FTaggedActorData Data)
 
float SetStencilValue (UPrimitiveComponent &Component, AActor &Actor, const ELabels &Label)
 
void TagLandscape (ALandscape *Landscape, AActor &Actor)
 
ELabels GetLabelFromString (const FString &String)
 
ELabels GetLabelFromStaticComponent (UStaticMeshComponent *StaticMeshComponentPtr)
 
ELabels GetLabelFromSkeletalMeshComponent (USkeletalMeshComponent *USkeletalMeshComponentPtr)
 
ELabels GetLabelFromPath (const FString &Path, FString &FolderName)
 
template<typename T >
ELabels GetLabelFromTag (const T *Object)
 

Private Attributes

AGeoReferencingSystem * GeoReferencingSystem = nullptr
 
UCSVFileCSVFile = nullptr
 
TArray< FTaggedActorDataTaggedActors
 
FDelegateHandle ActorSpawnedDelegateHandle
 
TMap< FString, ELabelsLabelMap
 
bool TerrainIDCached = false
 
uint32 CachedTerrainID = 0
 
float ID = 1.0f
 
TMap< ELabels, int32 > LabelCounters
 

Detailed Description

Definition at line 50 of file Tagger.h.

Constructor & Destructor Documentation

◆ ATagger()

ATagger::ATagger ( )

Definition at line 26 of file Tagger.cpp.

27{
28 PrimaryActorTick.bCanEverTick = false;
29}

Member Function Documentation

◆ BeginPlay()

void ATagger::BeginPlay ( )
overrideprotectedvirtual

Definition at line 31 of file Tagger.cpp.

32{
33 Super::BeginPlay();
34
36 {
37 return;
38 }
39
40 UWorld* World = GetWorld();
41
42 // Create TMap<FString, ELabels>
43 LabelMap = UEnumUtilities::CreateStringEnumMap<ELabels>("/Script/Agrarsense.ELabels");
44
45 ActorSpawnedDelegateHandle = World->AddOnActorSpawnedHandler(FOnActorSpawned::FDelegate::CreateUObject(this, &ATagger::OnActorSpawned));
46
47 // Tag all existing Actors in the World after small delay
48 FTimerHandle Handle;
49 World->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
50 {
52 }), 0.200f, false);
53}
TMap< FString, ELabels > LabelMap
Definition: Tagger.h:115
void OnActorSpawned(AActor *Actor)
Definition: Tagger.cpp:87
void TagExistingActors()
Definition: Tagger.cpp:63
FDelegateHandle ActorSpawnedDelegateHandle
Definition: Tagger.h:113
static bool IsPlayingInMainMenu()

References ActorSpawnedDelegateHandle, UAgrarsenseSettings::IsPlayingInMainMenu(), LabelMap, OnActorSpawned(), and TagExistingActors().

◆ CreateCSVFile()

void ATagger::CreateCSVFile ( )
protected

Definition at line 239 of file Tagger.cpp.

240{
241 GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
242
243 // CSV file settings
244 FCSVFileSettings Settings;
246 Settings.Append = false;
247 Settings.CreateUnique = true;
249
250 FString MapName = GetWorld()->GetMapName();
251 FString FileName = MapName + TEXT("_ObjectLocations");
252
253 if (MapName.Contains("dev"))
254 {
255 Settings.QueueSize = 65536;
256 }
257
258 CSVFile = UCSVFile::CreateCSVFile(FileName, Settings);
259
260 TArray<FString> Header = { TEXT("Name"), TEXT("InstanceID"), TEXT("LocationX"), TEXT("LocationY"),
261 TEXT("LocationZ"), TEXT("Yaw"), TEXT("Pitch"), TEXT("Roll"), TEXT("Bounds")};
263 {
264 Header.Append({ TEXT("Latitude"), TEXT("Longitude"), TEXT("Altitude") });
265 }
266 CSVFile->WriteRow(Header);
267}
AGeoReferencingSystem * GeoReferencingSystem
Definition: Tagger.h:107
UCSVFile * CSVFile
Definition: Tagger.h:109
static UCSVFile * CreateCSVFile(const FString &FileNameWithoutExtension, const FCSVFileSettings &Settings)
Definition: CSVFile.cpp:14
void WriteRow(const TArray< FString > &Cells)
Definition: CSVFile.cpp:77
bool CreateUnique
Definition: CSVFile.h:42
ECSVDelimiter Delimiter
Definition: CSVFile.h:36
int32 QueueSize
Definition: CSVFile.h:48
FCSVFileWriteOptions FileWriteOption
Definition: CSVFile.h:45

References FCSVFileSettings::Append, UCSVFile::CreateCSVFile(), FCSVFileSettings::CreateUnique, CSVFile, FCSVFileSettings::Delimiter, FCSVFileSettings::FileWriteOption, GeoReferencingSystem, Queue, FCSVFileSettings::QueueSize, Semicolon, and UCSVFile::WriteRow().

Referenced by ExportObjectLocationsToCSV().

◆ EndPlay()

void ATagger::EndPlay ( const EEndPlayReason::Type  EndPlayReason)
overrideprotectedvirtual

Definition at line 55 of file Tagger.cpp.

56{
57 Super::EndPlay(EndPlayReason);
58
59 TaggedActors.Empty();
61}
TArray< FTaggedActorData > TaggedActors
Definition: Tagger.h:111

References ActorSpawnedDelegateHandle, and TaggedActors.

◆ ExportObjectLocationsToCSV()

void ATagger::ExportObjectLocationsToCSV ( )

Definition at line 199 of file Tagger.cpp.

200{
201 if (TaggedActors.IsEmpty())
202 {
203 return;
204 }
205
207 if (!CSVFile)
208 {
209 return;
210 }
211
212 for (const FTaggedActorData& TaggedActorData : TaggedActors)
213 {
214 AActor* Actor = TaggedActorData.Actor;
215 if (!Actor)
216 {
217 continue;
218 }
219
220 WriteComponentToCSV(TaggedActorData);
221 }
222
223 CSVFile->Close();
224}
void CreateCSVFile()
Definition: Tagger.cpp:239
void WriteComponentToCSV(const FTaggedActorData Data)
Definition: Tagger.cpp:269
void Close()
Definition: CSVFile.cpp:115

References UCSVFile::Close(), CreateCSVFile(), CSVFile, TaggedActors, and WriteComponentToCSV().

◆ GetActorByInstanceID()

AActor * ATagger::GetActorByInstanceID ( float  InstanceID)

Definition at line 226 of file Tagger.cpp.

227{
228 for (const FTaggedActorData& TaggedActorData : TaggedActors)
229 {
230 if (TaggedActorData.InstanceID == InstanceID)
231 {
232 return TaggedActorData.Actor;
233 }
234 }
235
236 return nullptr;
237}

References TaggedActors.

Referenced by UROSCommands::HandleDestroyObjectByInstanceID(), and UROSCommands::HandleTeleportSpectatorByInstanceID().

◆ GetLabelFromPath()

ELabels ATagger::GetLabelFromPath ( const FString &  Path,
FString &  FolderName 
)
protected

Definition at line 455 of file Tagger.cpp.

456{
457 ELabels Label = ELabels::None;
458
459 // If the Path doesn't contain Models,
460 // the asset is not under /Content/Agrarsense/Models directory
461 // meaing we ignore it.
462 if (!Path.Contains("Models"))
463 {
464 return Label;
465 }
466
467 TArray<FString> StringArray;
468 Path.ParseIntoArray(StringArray, TEXT("/"), false);
469
470 FolderName = StringArray[StringArray.Num() - 2];
471
472 Label = GetLabelFromString(FolderName);
473
474 return Label;
475}
ELabels
Definition: ObjectLabel.h:14
ELabels GetLabelFromString(const FString &String)
Definition: Tagger.cpp:379

References GetLabelFromString(), and None.

Referenced by GetLabelFromSkeletalMeshComponent(), and GetLabelFromStaticComponent().

◆ GetLabelFromSkeletalMeshComponent()

ELabels ATagger::GetLabelFromSkeletalMeshComponent ( USkeletalMeshComponent *  USkeletalMeshComponentPtr)
protected

Definition at line 425 of file Tagger.cpp.

426{
427 ELabels Label = ELabels::None;
428
429 if (!USkeletalMeshComponentPtr)
430 {
431 return Label;
432 }
433
434 Label = GetLabelFromTag(USkeletalMeshComponentPtr);
435 if (Label != ELabels::None)
436 {
437 return Label;
438 }
439
440 USkeletalMesh* PhysicsAsset = USkeletalMeshComponentPtr->GetSkeletalMeshAsset();
441 if (PhysicsAsset)
442 {
443 FString Name;
444 Label = GetLabelFromPath(PhysicsAsset->GetPathName(), Name);
445
446 if (Label != ELabels::None)
447 {
448 USkeletalMeshComponentPtr->ComponentTags.Insert(FName(Name), 0);
449 }
450 }
451
452 return Label;
453}
ELabels GetLabelFromPath(const FString &Path, FString &FolderName)
Definition: Tagger.cpp:455
ELabels GetLabelFromTag(const T *Object)
Definition: Tagger.h:95

References GetLabelFromPath(), GetLabelFromTag(), and None.

Referenced by TagActor().

◆ GetLabelFromStaticComponent()

ELabels ATagger::GetLabelFromStaticComponent ( UStaticMeshComponent *  StaticMeshComponentPtr)
protected

Definition at line 395 of file Tagger.cpp.

396{
397 ELabels Label = ELabels::None;
398
399 if (!StaticMeshComponentPtr)
400 {
401 return Label;
402 }
403
404 Label = GetLabelFromTag(StaticMeshComponentPtr);
405 if (Label != ELabels::None)
406 {
407 return Label;
408 }
409
410 UStaticMesh* MeshPtr = StaticMeshComponentPtr->GetStaticMesh();
411 if (MeshPtr)
412 {
413 FString Name;
414 Label = GetLabelFromPath(MeshPtr->GetPathName(), Name);
415
416 if (Label != ELabels::None)
417 {
418 StaticMeshComponentPtr->ComponentTags.Insert(FName(Name), 0);
419 }
420 }
421
422 return Label;
423}

References GetLabelFromPath(), GetLabelFromTag(), and None.

Referenced by TagActor().

◆ GetLabelFromString()

ELabels ATagger::GetLabelFromString ( const FString &  String)
protected

Definition at line 379 of file Tagger.cpp.

380{
381 const ELabels* FoundLabel = LabelMap.Find(String);
382 if (FoundLabel)
383 {
384 return *FoundLabel;
385 }
386 else
387 {
388#if WITH_EDITOR
389 UE_LOG(LogTemp, Warning, TEXT("Tagger.cpp: Missing Label: %s"), *String);
390#endif
391 return ELabels::None;
392 }
393}

References LabelMap, and None.

Referenced by GetLabelFromPath().

◆ GetLabelFromTag()

template<typename T >
ELabels ATagger::GetLabelFromTag ( const T *  Object)
inlineprotected

Definition at line 95 of file Tagger.h.

96 {
97 if (!Object->ComponentTags.IsEmpty())
98 {
99 return GetLabelFromString(Object->ComponentTags[0].ToString());
100 }
101
102 return ELabels::None;
103 }

References None.

Referenced by GetLabelFromSkeletalMeshComponent(), and GetLabelFromStaticComponent().

◆ OnActorSpawned()

void ATagger::OnActorSpawned ( AActor *  Actor)
protected

Definition at line 87 of file Tagger.cpp.

88{
89 if (Actor)
90 {
91 TagActor(*Actor);
92 }
93}
void TagActor(AActor &Actor)
Definition: Tagger.cpp:101

References TagActor().

Referenced by BeginPlay().

◆ SetStencilValue()

float ATagger::SetStencilValue ( UPrimitiveComponent &  Component,
AActor &  Actor,
const ELabels Label 
)
protected

Definition at line 170 of file Tagger.cpp.

171{
172 Component.SetRenderCustomDepth(true);
173
174 const int32 ActorLabelStencilValue = static_cast<int32>(Label);
175 float ActorLabelStencilValueFloat = static_cast<float>(ActorLabelStencilValue);
176
177 Component.SetCustomDepthStencilValue(ActorLabelStencilValue + 1);
178
179 int32& Counter = LabelCounters.FindOrAdd(Label); // default 0 on first use
180 Counter += 1; // assign next id
181 const int32 CurrentIntID = Counter; // 1..n for this label
182 const float CurrentID = static_cast<float>(CurrentIntID);
183
184 // Write custom primitive data (X=per-label instance id, Y=semantic/stencil)
185 Component.SetCustomPrimitiveDataVector4f(4,
186 FVector4f(CurrentID,
187 ActorLabelStencilValueFloat,
188 0.0f,
189 0.0f));
190
191 Component.MarkRenderStateDirty();
192
193 /*UE_LOG(LogTemp, Log, TEXT("Per-label ID %f -> Actor %s (Label %d)"),
194 CurrentID, *Actor.GetName(), static_cast<int32>(Label));*/
195
196 return CurrentID;
197}
TMap< ELabels, int32 > LabelCounters
Definition: Tagger.h:126

References LabelCounters.

Referenced by TagActor().

◆ TagActor()

void ATagger::TagActor ( AActor &  Actor)
protected

Definition at line 101 of file Tagger.cpp.

102{
103//#ifndef InstanceSegmentationPass_EXISTS
104// AInstancedActor* InstancedActor = Cast<AInstancedActor>(&Actor);
105// if (InstancedActor)
106// {
107// if (InstancedActor->IsCustomDepthSetup())
108// {
109// // Custom depth has been setup beforehand. Return
110// return;
111// }
112// }
113//
114// AWalker* Walker = Cast<AWalker>(&Actor);
115// if (Walker)
116// {
117// // If the actor is AWalker, return. These are tagged in editor.
118// return;
119// }
120//#endif
121
122 // Check if this is a Landscape actor
123 // if so, apply same ID and label to all landscape and its components.
124 ALandscape* Landscape = Cast<ALandscape>(&Actor);
125 if (Landscape)
126 {
127 TagLandscape(Landscape, Actor);
128 return;
129 }
130
131 // Iterate all static meshes
132 TArray<UStaticMeshComponent*> StaticMeshComponents;
133 Actor.GetComponents<UStaticMeshComponent>(StaticMeshComponents);
134 for (UStaticMeshComponent* Component : StaticMeshComponents)
135 {
136 if (Component)
137 {
138 ELabels Label = GetLabelFromStaticComponent(Component);
139 float InstanceSegmentationID = SetStencilValue(*Component, Actor, Label);
140
141 FTaggedActorData ActorData;
142 ActorData.Actor = &Actor;
143 ActorData.InstanceID = InstanceSegmentationID;
144 ActorData.StaticMeshComponent = Component;
145 ActorData.Label = Label;
146 TaggedActors.Add(ActorData);
147 }
148 }
149
150 // Iterate all skeletal meshes
151 TArray<USkeletalMeshComponent*> SkeletalMeshComponents;
152 Actor.GetComponents<USkeletalMeshComponent>(SkeletalMeshComponents);
153 for (USkeletalMeshComponent* Component : SkeletalMeshComponents)
154 {
155 if (Component)
156 {
158 float InstanceSegmentationID = SetStencilValue(*Component, Actor, Label);
159
160 FTaggedActorData ActorData;
161 ActorData.Actor = &Actor;
162 ActorData.InstanceID = InstanceSegmentationID;
163 ActorData.SkeletalMeshComponent = Component;
164 ActorData.Label = Label;
165 TaggedActors.Add(ActorData);
166 }
167 }
168}
ELabels GetLabelFromStaticComponent(UStaticMeshComponent *StaticMeshComponentPtr)
Definition: Tagger.cpp:395
ELabels GetLabelFromSkeletalMeshComponent(USkeletalMeshComponent *USkeletalMeshComponentPtr)
Definition: Tagger.cpp:425
float SetStencilValue(UPrimitiveComponent &Component, AActor &Actor, const ELabels &Label)
Definition: Tagger.cpp:170
void TagLandscape(ALandscape *Landscape, AActor &Actor)
Definition: Tagger.cpp:345
float InstanceID
Definition: Tagger.h:37
ELabels Label
Definition: Tagger.h:40
AActor * Actor
Definition: Tagger.h:28
UStaticMeshComponent * StaticMeshComponent
Definition: Tagger.h:31
USkeletalMeshComponent * SkeletalMeshComponent
Definition: Tagger.h:34

References FTaggedActorData::Actor, GetLabelFromSkeletalMeshComponent(), GetLabelFromStaticComponent(), FTaggedActorData::InstanceID, FTaggedActorData::Label, SetStencilValue(), FTaggedActorData::SkeletalMeshComponent, FTaggedActorData::StaticMeshComponent, TaggedActors, and TagLandscape().

Referenced by OnActorSpawned(), and TagExistingActors().

◆ TagExistingActors()

void ATagger::TagExistingActors ( )
protected

Definition at line 63 of file Tagger.cpp.

64{
65 TArray<AActor*> Actors;
66 UGameplayStatics::GetAllActorsOfClass(GetWorld(), AActor::StaticClass(), Actors);
67
68 TaggedActors.Reserve(Actors.Num());
69
70 // Sort actors based on distance to the origin (0,0,0)
71 // This way we can ensure that the actors are tagged in a consistent order each run
72 const FVector Origin(0.0f, 0.0f, 0.0f);
73 Actors.Sort([&](const AActor& A, const AActor& B)
74 {
75 return FVector::DistSquared(A.GetActorLocation(), Origin) < FVector::DistSquared(B.GetActorLocation(), Origin);
76 });
77
78 for (AActor* Actor : Actors)
79 {
80 if (Actor)
81 {
82 TagActor(*Actor);
83 }
84 }
85}

References TagActor(), and TaggedActors.

Referenced by BeginPlay().

◆ TagLandscape()

void ATagger::TagLandscape ( ALandscape *  Landscape,
AActor &  Actor 
)
protected

Definition at line 345 of file Tagger.cpp.

346{
347 if (!Landscape)
348 {
349 return;
350 }
351
352 // Do not change. hardcoded values for landscape.
353 // So each landscape section has same ID and label.
354 constexpr float LANDSCAPE_LABEL = 1.0f;
355 constexpr float LANDSCAPE_ID = 0.0f;
356
357 // For some reason we needed to loop UStaticMeshComponents instead of ULandscapeComponents
358 TArray<UStaticMeshComponent*> StaticMeshComponents;
359 Actor.GetComponents<UStaticMeshComponent>(StaticMeshComponents);
360 for (UStaticMeshComponent* Component : StaticMeshComponents)
361 {
362 if (Component)
363 {
364 Component->SetRenderCustomDepth(true);
365 Component->SetCustomDepthStencilValue(static_cast<int32>(ELabels::Terrain) + 1);
366
367#ifdef InstanceSegmentationPass_EXISTS
368 // Set custom primitive data, used for instance segmentation.
369 Component->SetCustomPrimitiveDataVector4f(4,
370 FVector4f(LANDSCAPE_ID,
371 LANDSCAPE_LABEL,
372 0.0f,
373 0.0f));
374#endif
375 }
376 }
377}

References Terrain.

Referenced by TagActor().

◆ WriteComponentToCSV()

void ATagger::WriteComponentToCSV ( const FTaggedActorData  Data)
protected

Definition at line 269 of file Tagger.cpp.

270{
271 AActor* Actor = Data.Actor;
272
273 if (!Actor)
274 {
275 return;
276 }
277
278 FString AssetPath;
279 FString MeshName;
280 FVector Location = Actor->GetActorLocation();
281 FRotator Rotation = Actor->GetActorRotation();
282 FBoxSphereBounds Bounds;
283
284 // Try StaticMeshComponent first
285 if (Data.StaticMeshComponent && Data.StaticMeshComponent->GetStaticMesh())
286 {
287 UStaticMesh* StaticMesh = Data.StaticMeshComponent->GetStaticMesh();
288 AssetPath = StaticMesh->GetPathName();
289 MeshName = StaticMesh->GetName();
290 Bounds = StaticMesh->GetBounds();
291 }
292 // If not valid, try SkeletalMeshComponent
293 else if (Data.SkeletalMeshComponent && Data.SkeletalMeshComponent->GetSkeletalMeshAsset())
294 {
295 USkeletalMesh* SkeletalMesh = Data.SkeletalMeshComponent->GetSkeletalMeshAsset();
296 AssetPath = SkeletalMesh->GetPathName();
297 MeshName = SkeletalMesh->GetName();
298 Bounds = SkeletalMesh->GetBounds();
299 }
300 else
301 {
302 return;
303 }
304
305 // Check asset path
306 if (!AssetPath.StartsWith(TEXT("/Game/Agrarsense/Models")))
307 {
308 return;
309 }
310
311 TArray<FString> Row;
312 Row.Reserve(GeoReferencingSystem ? 12 : 9);
313
314 Row.Add(MeshName);
315 Row.Add(FString::Printf(TEXT("%.0f"), Data.InstanceID));
316
317 // TODO add semantic label to the CSV
318 Row.Add(FString::Printf(TEXT("%.2f"), Location.X));
319 Row.Add(FString::Printf(TEXT("%.2f"), Location.Y));
320 Row.Add(FString::Printf(TEXT("%.2f"), Location.Z));
321 Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Yaw));
322 Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Pitch));
323 Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Roll));
324
325 // Bounds
326 Row.Add(FString::Printf(TEXT("Origin=(%.2f,%.2f,%.2f),BoxExtent=(%.2f,%.2f,%.2f),SphereRadius=%.2f"),
327 Bounds.Origin.X, Bounds.Origin.Y, Bounds.Origin.Z,
328 Bounds.BoxExtent.X, Bounds.BoxExtent.Y, Bounds.BoxExtent.Z,
329 Bounds.SphereRadius));
330
332 {
333 const FGeographicCoordinates GeoCoords = UCoordinateConversionUtilities::UnrealToGeographicCoordinates(GeoReferencingSystem, Location);
334 Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Latitude));
335 Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Longitude));
336 Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Altitude));
337 }
338
339 if (CSVFile)
340 {
341 CSVFile->WriteRow(Row);
342 }
343}
static FGeographicCoordinates UnrealToGeographicCoordinates(AGeoReferencingSystem *GeoReferencingSystem, const FVector &Position)

References FTaggedActorData::Actor, CSVFile, GeoReferencingSystem, FTaggedActorData::InstanceID, FTaggedActorData::SkeletalMeshComponent, FTaggedActorData::StaticMeshComponent, UCoordinateConversionUtilities::UnrealToGeographicCoordinates(), and UCSVFile::WriteRow().

Referenced by ExportObjectLocationsToCSV().

Member Data Documentation

◆ ActorSpawnedDelegateHandle

FDelegateHandle ATagger::ActorSpawnedDelegateHandle
private

Definition at line 113 of file Tagger.h.

Referenced by BeginPlay(), and EndPlay().

◆ CachedTerrainID

uint32 ATagger::CachedTerrainID = 0
private

Definition at line 119 of file Tagger.h.

◆ CSVFile

UCSVFile* ATagger::CSVFile = nullptr
private

Definition at line 109 of file Tagger.h.

Referenced by CreateCSVFile(), ExportObjectLocationsToCSV(), and WriteComponentToCSV().

◆ GeoReferencingSystem

AGeoReferencingSystem* ATagger::GeoReferencingSystem = nullptr
private

Definition at line 107 of file Tagger.h.

Referenced by CreateCSVFile(), and WriteComponentToCSV().

◆ ID

float ATagger::ID = 1.0f
private

Definition at line 123 of file Tagger.h.

◆ LabelCounters

TMap<ELabels, int32> ATagger::LabelCounters
private

Definition at line 126 of file Tagger.h.

Referenced by SetStencilValue().

◆ LabelMap

TMap<FString, ELabels> ATagger::LabelMap
private

Definition at line 115 of file Tagger.h.

Referenced by BeginPlay(), and GetLabelFromString().

◆ TaggedActors

TArray<FTaggedActorData> ATagger::TaggedActors
private

◆ TerrainIDCached

bool ATagger::TerrainIDCached = false
private

Definition at line 117 of file Tagger.h.


The documentation for this class was generated from the following files: