NVIDIA DeepLearning Dataset Synthesizer (NDDS)
 All Classes Namespaces Functions Variables Typedefs Pages
NVSceneCapturerUtils.h
1 /*
2 * Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
3 *
4 * NVIDIA CORPORATION and its licensors retain all intellectual property
5 * and proprietary rights in and to this software, related documentation
6 * and any modifications thereto. Any use, reproduction, disclosure or
7 * distribution of this software and related documentation without an express
8 * license agreement from NVIDIA CORPORATION is strictly prohibited.
9 */
10 
11 #pragma once
12 #include "NVSceneCapturerModule.h"
13 #include "IImageWrapper.h"
14 #include "Runtime/Core/Public/Misc/FileHelper.h"
15 #include "Kismet/BlueprintFunctionLibrary.h"
16 #include "Serialization/JsonSerializerMacros.h"
17 #include "Serialization/JsonTypes.h"
18 #include "Paths.h"
19 #include "SharedPointer.h"
20 #include "Engine/TextureRenderTarget2D.h"
21 #include "JsonObjectConverter.h"
22 #include "Json.h"
23 #include "NVCameraSettings.h"
24 #include "NVSceneCapturerUtils.generated.h"
25 
26 // NOTE: Should remove this enum when the EImageFormat in IImageWrapper marked as UENUM
27 UENUM(BlueprintType)
28 enum class ENVImageFormat : uint8
29 {
30  /// Portable Network Graphics.
31  PNG UMETA(DisplayName = "PNG (Portable Network Graphics)."),
32 
33  /// Joint Photographic Experts Group.
34  JPEG UMETA(DisplayName = "JPEG (Joint Photographic Experts Group)."),
35 
36  /// Single channel jpeg.
37  GrayscaleJPEG UMETA(DisplayName = "GrayscaleJPEG (Single channel jpeg"),
38 
39  /// Windows Bitmap.
40  BMP UMETA(DisplayName = "BMP (Windows Bitmap"),
41 
42  // OpenEXR (HDR) image file format
43  // TODO: Support HDR format
44  // EXR UMETA(DisplayName = "EXR (OpenEXR (HDR) image"),
45 
46  /// @cond DOXYGEN_SUPPRESSED_CODE
47  NVImageFormat_MAX UMETA(Hidden)
48  /// @endcond DOXYGEN_SUPPRESSED_CODE
49 };
50 EImageFormat ConvertExportFormatToImageFormat(ENVImageFormat ExportFormat);
51 FString GetExportImageExtension(ENVImageFormat ExportFormat);
52 
53 /// The pixel format which can be captured
54 UENUM()
55 enum ENVCapturedPixelFormat
56 {
57  /// R channel, 8 bit per channel fixed point, range [0, 1]
58  /// Use this format for the grayscale 8 bit image type
59  R8,
60 
61  /// RGBA channels, 8 bit per channel fixed point, range [0, 1]
62  /// Use this format for the normal full color image type
63  RGBA8,
64 
65  /// R channel, 16 bit per channel floating point, range [-65504, 65504]
66  /// Use this format for the grayscale 16 bits image type
67  R16f,
68 
69  /// R channel, 32 bit per channel floating point, range [-3.402823 x 10^38, 3.402823 x 10^38]
70  /// NOTE: This format capture to 32 bits floating point value and can be exported to RGBA8 format
71  R32f,
72 
73  /// @cond DOXYGEN_SUPPRESSED_CODE
74  NVCapturedPixelFormat_MAX UMETA(Hidden)
75  /// @endcond DOXYGEN_SUPPRESSED_CODE
76 };
77 ETextureRenderTargetFormat ConvertCapturedFormatToRenderTargetFormat(ENVCapturedPixelFormat PixelFormat);
78 
79 USTRUCT()
81 {
82  GENERATED_BODY()
83 
84 public:
85  UPROPERTY(Transient)
86  TArray<uint8> PixelData;
87 
88  EPixelFormat PixelFormat;
89  UPROPERTY(Transient)
90  uint32 RowStride;
91  UPROPERTY(Transient)
92  FIntPoint PixelSize;
93 };
94 
95 /// Data to be captured and exported for each socket
96 USTRUCT()
97 struct NVSCENECAPTURER_API FNVSocketData
98 {
99  GENERATED_BODY()
100 
101 public:
102  UPROPERTY()
103  FString SocketName;
104 
105  UPROPERTY()
106  FVector2D SocketLocation;
107 };
108 
109 /// This enum represent 8 corner vertexes of a rectangular cuboid
110 /// NOTE: The order of the enums here is what the researcher want for the training data.
111 /// If they want to change the exported order of these vertexes then we must update this order too
112 UENUM(BlueprintType)
113 enum class ENVCuboidVertexType : uint8
114 {
115  FrontTopRight = 0,
116  FrontTopLeft,
117  FrontBottomLeft,
118  FrontBottomRight,
119  RearTopRight,
120  RearTopLeft,
121  RearBottomLeft,
122  RearBottomRight,
123 
124  CuboidVertexType_MAX UMETA(Hidden)
125 };
126 
127 USTRUCT(BlueprintType)
128 struct NVSCENECAPTURER_API FNVCuboidData
129 {
130  GENERATED_BODY();
131 
132 public:
133  /// List of position for each vertexes in the cuboid
134  UPROPERTY()
135  FVector Vertexes[(uint8)ENVCuboidVertexType::CuboidVertexType_MAX];
136 
137  static uint8 TotalVertexesCount;
138 
139 public:
140  FNVCuboidData();
141  FNVCuboidData(const FBox& AABB);
142  FNVCuboidData(const FBox& LocalBox, const FTransform& LocalTransform);
143 
144  void BuildFromAABB(const FBox& AABB);
145  void BuildFromOOBB(const FBox& OOBB, const FTransform& LocalTransform);
146 
147  FVector GetCenter() const
148  {
149  return Center;
150  }
151  FVector GetVertex(ENVCuboidVertexType VertexType) const
152  {
153  return Vertexes[(uint8)VertexType];
154  }
155  FVector GetExtent() const
156  {
157  return LocalBox.GetExtent();
158  };
159  FVector GetDimension() const
160  {
161  return LocalBox.GetExtent() * 2.f;
162  }
163  FVector GetDirection() const
164  {
165  return Rotation.Vector();
166  }
167  FQuat GetRotation() const
168  {
169  return Rotation;
170  }
171  bool IsValid() const
172  {
173  return (LocalBox.IsValid != 0);
174  };
175 
176 private:
177  /// The center position of the cuboid
178  UPROPERTY()
179  FVector Center;
180 
181  UPROPERTY()
182  FBox LocalBox;
183 
184  UPROPERTY()
185  FQuat Rotation;
186 };
187 
188 USTRUCT()
189 struct NVSCENECAPTURER_API FNVBox2D
190 {
191  GENERATED_BODY()
192 
193  FNVBox2D(const FBox2D& box = FBox2D())
194  {
195  top_left = FVector2D(box.Min.Y, box.Min.X);
196  bottom_right = FVector2D(box.Max.Y, box.Max.X);
197  }
198 
199 public:
200  UPROPERTY()
201  FVector2D top_left;
202 
203  UPROPERTY()
204  FVector2D bottom_right;
205 };
206 
207 USTRUCT()
208 struct NVSCENECAPTURER_API FCapturedObjectData
209 {
210  GENERATED_BODY()
211 
212 public: // Properties
213  /// Object's name
214  UPROPERTY(Transient)
215  FString Name;
216 
217  /// Name of the object's class
218  UPROPERTY()
219  FString Class;
220 
221  UPROPERTY(Transient)
222  float truncated;
223 
224  UPROPERTY(Transient)
225  uint32 occluded;
226 
227  /// Fraction of how much the object's 2d bounding box get occluded
228  UPROPERTY(Transient)
229  float occlusion;
230 
231  UPROPERTY()
232  float visibility;
233 
234  UPROPERTY(Transient)
235  FVector dimensions_worldspace;
236 
237  UPROPERTY(Transient)
238  FVector location_worldspace;
239 
240  UPROPERTY()
241  FVector location;
242 
243  UPROPERTY(Transient)
244  FRotator rotation_worldspace;
245 
246  UPROPERTY(Transient)
247  FQuat quaternion_worldspace;
248 
249  UPROPERTY(Transient)
250  FRotator rotation;
251 
252  UPROPERTY()
253  FQuat quaternion_xyzw;
254 
255  UPROPERTY(Transient)
256  FMatrix actor_to_world_matrix_ue4;
257 
258  UPROPERTY(Transient)
259  FMatrix actor_to_world_matrix_opencv;
260 
261  UPROPERTY(Transient)
262  FMatrix actor_to_camera_matrix;
263 
264  UPROPERTY()
265  FMatrix pose_transform;
266 
267  UPROPERTY(Transient)
268  FVector bounding_box_center_worldspace;
269 
270  UPROPERTY()
271  FVector cuboid_centroid;
272 
273  UPROPERTY()
274  FVector2D projected_cuboid_centroid;
275 
276  UPROPERTY(Transient)
277  FVector bounding_box_forward_direction;
278 
279  UPROPERTY(Transient)
280  FVector2D bounding_box_forward_direction_imagespace;
281 
282  UPROPERTY(Transient)
283  float viewpoint_azimuth_angle;
284 
285  UPROPERTY(Transient)
286  float viewpoint_altitude_angle;
287 
288  UPROPERTY(Transient)
289  float distance_scale;
290 
291  UPROPERTY()
292  FNVBox2D bounding_box;
293 
294  // TODO: Create a struct for the cuboid since it must have exactly 8 corner vertexes
295  UPROPERTY()
296  TArray<FVector> cuboid;
297 
298  UPROPERTY()
299  TArray<FVector2D> projected_cuboid;
300 
301  UPROPERTY(Transient)
302  TArray<FNVSocketData> socket_data;
303 
304  TSharedPtr<FJsonObject> custom_data;
305 };
306 
307 USTRUCT()
308 struct NVSCENECAPTURER_API FCapturedViewpointData
309 {
310  GENERATED_BODY()
311 
312 
313 public: // Editor properties
314  UPROPERTY()
315  FVector location_worldframe;
316 
317  UPROPERTY()
318  FQuat quaternion_xyzw_worldframe;
319 
320  UPROPERTY(Transient)
321  FMatrix ProjectionMatrix;
322 
323  UPROPERTY(Transient)
324  FMatrix ViewProjectionMatrix;
325 
326  UPROPERTY(Transient)
327  FCameraIntrinsicSettings CameraSettings;
328 
329  UPROPERTY(Transient)
330  float fov;
331 
332  // TODO: Add the view projection matrix
333 };
334 
335 USTRUCT()
336 struct NVSCENECAPTURER_API FCapturedSceneData
337 {
338  GENERATED_BODY()
339 
340 public: // Editor properties
341  UPROPERTY()
342  FCapturedViewpointData camera_data;
343 
344  UPROPERTY()
345  TArray<FCapturedObjectData> Objects;
346 };
347 
348 USTRUCT()
349 struct NVSCENECAPTURER_API FCapturedFrameData
350 {
351  GENERATED_BODY()
352 
353 public:
354  UPROPERTY()
355  FCapturedSceneData Data;
356 
357  // Pixels data of the frame
358  UPROPERTY()
359  TArray<FColor> SceneBitmap;
360 };
361 
362 
363 UCLASS(ClassGroup = (NVIDIA), meta = (BlueprintSpawnableComponent))
364 class NVSCENECAPTURER_API UNVCapturableActorTag : public UActorComponent
365 {
366  GENERATED_BODY()
367 public:
368  UNVCapturableActorTag() : bIncludeMe(true) {};
369 
370  bool IsValid() const { return bIncludeMe && !Tag.IsEmpty(); }
371 
372 public: // Editor properties
373  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
374  FString Tag;
375 
376  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
377  bool bIncludeMe;
378 
379  /// If true, find all the socket in the owner's meshes and export all of their name and transform data
380  /// Otherwise only export socket in the list
381  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
382  bool bExportAllMeshSocketInfo;
383 
384  /// List of the name of the sockets from the owner's mesh need to be exported
385  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config", meta = (editcondition = "!bExportAllMeshSocketInfo"))
386  TArray<FName> SocketNameToExportList;
387 };
388 
389 UENUM(BlueprintType)
390 enum class ENVIncludeObjects : uint8
391 {
392  AllTaggedObjects,
393  MatchesTag
394 };
395 
396 UENUM(BlueprintType)
397 enum class ENVBoundsGenerationType : uint8
398 {
399  /// World space AABB
400  VE_AABB UMETA(DisplayName = "AABB"),
401  /// Object Space AABB, scaled, rotated and translated
402  VE_OOBB UMETA(DisplayName = "OOBB"),
403  /// Arbitrary tight fitting bounds generated from mesh vertices.
404  /// REMOVE: May not support this
405  VE_TightOOBB UMETA(DisplayName = "Tight Arbitrary OOBB")
406 };
407 
408 UENUM(BlueprintType)
409 enum class ENVBoundBox2dGenerationType : uint8
410 {
411  /// Generate the 2d bounding box from the mesh's 3d bounding box vertexes
412  From3dBoundingBox,
413 
414  /// Generate the 2d bounding box from the mesh's body collision
415  FromMeshBodyCollision,
416 };
417 
418 USTRUCT(BlueprintType)
419 struct NVSCENECAPTURER_API FNVSceneExporterConfig
420 {
421  GENERATED_BODY()
422 
423 public:
424  FNVSceneExporterConfig();
425 
426 protected: // Editor properties
427  UPROPERTY(EditAnywhere, Category = "Export")
428  bool bExportObjectData;
429 
430  UPROPERTY(EditAnywhere, Category = "Export")
431  bool bExportScreenShot;
432 
433  UPROPERTY(EditAnywhere, Category = "Export")
434  ENVIncludeObjects IncludeObjectsType;
435 
436  /// If true, the exporter will ignore all the hidden actors in game
437  // TODO (TT): Should remove ENVIncludeObjects::AllVisibleObjects and keep this flag option independently from the InludeObjectsType
438  UPROPERTY(EditAnywhere, Category = "Export")
439  bool bIgnoreHiddenActor;
440 
441  /// How to generate 3d bounding box for each exported actor mesh
442  UPROPERTY(EditAnywhere, Category = "Export")
443  ENVBoundsGenerationType BoundsType;
444 
445  /// How to generate the 2d bounding box for each exported actor mesh
446  UPROPERTY(EditAnywhere, Category = "Export")
447  ENVBoundBox2dGenerationType BoundingBox2dType;
448 
449  UPROPERTY(EditAnywhere, Category = "Export")
450  bool bOutputEvenIfNoObjectsAreInView;
451 
452  // TODO: Should move this to the data feature extractors
453  UPROPERTY(EditAnywhere, Category = "Export")
454  FFloatInterval DistanceScaleRange;
455 };
456 
457 USTRUCT(BlueprintType)
458 struct NVSCENECAPTURER_API FNVSceneCapturerSettings
459 {
460  GENERATED_BODY();
461 
462 public:
463  FNVSceneCapturerSettings();
464 
465  float GetFOVAngle() const;
466  void RandomizeSettings();
467  FCameraIntrinsicSettings GetCameraIntrinsicSettings() const;
468 
469 #if WITH_EDITORONLY_DATA
470  void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent);
471 #endif //WITH_EDITORONLY_DATA
472 
473 public: // Editor properties
474  UPROPERTY(VisibleAnywhere, Category = CapturerSettings)
475  ENVImageFormat ExportImageFormat;
476 
477  UPROPERTY(Transient, VisibleAnywhere, Category = CapturerSettings, meta = (EditCondition = "!bUseExplicitCameraIntrinsic"))
478  float FOVAngle;
479 
480  UPROPERTY(EditAnywhere, Category = CapturerSettings, meta = (DisplayName = "Field of View", UIMin = "5.0", UIMax = "170", ClampMin = "0.001", ClampMax = "360.0", EditCondition = "!bUseExplicitCameraIntrinsic"))
481  FFloatInterval FOVAngleRange;
482 
483  UPROPERTY(EditAnywhere, Category = CapturerSettings)
484  FNVImageSize CapturedImageSize;
485 
486  /// NOTE: Only advance user who need to change this
487  UPROPERTY(EditAnywhere, AdvancedDisplay, Category = CapturerSettings)
488  int32 MaxSaveImageAsyncTaskCount;
489 
490  UPROPERTY(EditAnywhere, Category = CapturerSettings)
491  bool bUseExplicitCameraIntrinsic;
492 
493  UPROPERTY(EditAnywhere, Category = CapturerSettings, meta = (EditCondition=bUseExplicitCameraIntrinsic))
494  FCameraIntrinsicSettings CameraIntrinsicSettings;
495 
496  UPROPERTY(VisibleAnywhere, AdvancedDisplay, Category = CapturerSettings)
497  FMatrix CameraIntrinsicMatrix;
498 
499  UPROPERTY(VisibleAnywhere, AdvancedDisplay, Category = CapturerSettings)
500  FMatrix CameraProjectionMatrix;
501 };
502 
503 UENUM()
504 enum class ENVSceneCapturerState : uint8
505 {
506  NotActive UMETA(DisplayName = "NotActive. The capturer is not active."),
507  Active UMETA(DisplayName = "Active. The capturer is active. but not started."),
508  Running UMETA(DisplayName = "Running. The capturer is running/exporting."),
509  Paused UMETA(DisplayName = "Paused. The capturer is paused, can be resumed."),
510  Completed UMETA(DisplayName = "Completed. The capturer finished exporting a batch."),
511 
512  NVSceneCapturerState_MAX UMETA(Hidden)
513 };
514 
515 /// Name of parameters that used in message format FText
517 {
518  extern const FString NotStarted_Str;
519  extern const FString Running_Str;
520  extern const FString Paused_Str;
521  extern const FString Completed_Str;
522 
523  NVSCENECAPTURER_API FString ConvertExporterStateToString(ENVSceneCapturerState ExporterState);
524 };
525 
526 USTRUCT(BlueprintType)
527 struct NVSCENECAPTURER_API FNVFrameCounter
528 {
529  GENERATED_BODY()
530 
531 public:
532  FNVFrameCounter();
533 
534  float GetFPS() const
535  {
536  return CachedFPS;
537  }
538  int32 GetTotalFrameCount() const
539  {
540  return TotalFrameCount;
541  }
542 
543  void Reset();
544  void IncreaseFrameCount(int AdditionalFrameCount = 1);
545  void SetFrameCount(int NewFrameCount);
546  void AddFrameDuration(float NewDuration, bool bIncreaseFrame = false);
547 
548 protected:
549  void UpdateFPS();
550 
551  int32 TotalFrameCount;
552  float CachedFPS;
553  int FPSAccumulatedFrames;
554  float FPSAccumulatedDuration;
555 };
556 
557 namespace NVSceneCapturerUtils
558 {
559  extern const FMatrix UE4ToOpenCVMatrix;
560  extern const FMatrix OpenCVToUE4Matrix;
561  extern const FMatrix ObjToUE4Matrix;
562  extern const uint32 MaxVertexColorID;
563 
564 
565  //================ Helper functions ================
566  NVSCENECAPTURER_API FQuat ConvertQuaternionToOpenCVCoordinateSystem(const FQuat& InQuat);
567  NVSCENECAPTURER_API FVector ConvertDimensionToOpenCVCoordinateSystem(const FVector& InDimension);
568 
569  NVSCENECAPTURER_API FString GetGameDataOutputFolder();
570  NVSCENECAPTURER_API FString GetDefaultDataOutputFolder();
571  NVSCENECAPTURER_API FString GetOutputFileFullPath(uint32 Index, FString Extension, const FString& Subfolder, FString Filename = TEXT(""), uint8 ZeroPad = 6);
572 
573  NVSCENECAPTURER_API TSharedPtr<FJsonValue> CustomPropertyToJsonValueFunc(UProperty* PropertyType, const void* Value);
574 
575  /// Convert a property to json value use our own shorthand format, e.g: for Vector3: [x, y, z] instead of {"x": x, "y": y, "z": z}
576  NVSCENECAPTURER_API TSharedPtr<FJsonValue> CustomPropertyToJsonValueFunc(UProperty* PropertyType, const void* Value);
577 
578  template<typename InStructType> TSharedPtr<FJsonObject> UStructToJsonObject(const InStructType& InStructData, int64 CheckFlags=0, int64 SkipFlags=0)
579  {
580  FJsonObjectConverter::CustomExportCallback CustomPropertyToJsonValue;
581  if (!CustomPropertyToJsonValue.IsBound())
582  {
583  CustomPropertyToJsonValue.BindStatic(&NVSceneCapturerUtils::CustomPropertyToJsonValueFunc);
584  }
585 
586  TSharedPtr<FJsonObject> JsonObj = FJsonObjectConverter::UStructToJsonObject(InStructData, CheckFlags, SkipFlags, &CustomPropertyToJsonValue);
587  return JsonObj;
588  }
589 
590  NVSCENECAPTURER_API bool SaveJsonObjectToFile(const TSharedPtr<FJsonObject>& JsonObjData, const FString& Filename);
591 
592  NVSCENECAPTURER_API FString GetExportImageExtension(EImageFormat ImageFormat);
593 
594  NVSCENECAPTURER_API UMeshComponent* GetFirstValidMeshComponent(const AActor* CheckActor);
595  /// Get the list of vertexes from the mesh's simple collision
596  NVSCENECAPTURER_API TArray<FVector> GetSimpleCollisionVertexes(const class UMeshComponent* MeshComp);
597 
598  /// Get the number of bit in each pixel
599  NVSCENECAPTURER_API uint8 GetBitCountPerChannel(EPixelFormat PixelFormat);
600  /// Get the number of channel in each pixel
601  NVSCENECAPTURER_API uint8 GetColorChannelCount(EPixelFormat PixelFormat);
602  NVSCENECAPTURER_API uint8 GetPixelByteSize(EPixelFormat PixelFormat);
603 
604  NVSCENECAPTURER_API FColor ConvertByteIndexToColor(uint8 Index);
605  NVSCENECAPTURER_API FColor ConvertInt32ToRGB(uint32 Value);
606  NVSCENECAPTURER_API FColor ConvertInt32ToRGBA(uint32 Value);
607  NVSCENECAPTURER_API FColor ConvertInt32ToVertexColor(uint32 Value);
608 
609  /// Set the vertexes of the meshes in an actor to use the same color
610  NVSCENECAPTURER_API void SetMeshVertexColor(AActor* MeshOwnerActor, const FColor& VertexColor);
611  NVSCENECAPTURER_API void ClearMeshVertexColor(AActor* MeshOwnerActor);
612 
613  /// Calculate the spherical coordinate of a target compare to an origin point.
614  /// Ref: https://en.wikipedia.org/wiki/Azimuth
615  /// NOTE: Assume the horizontal plane is the XY plane in the world coordinate
616  NVSCENECAPTURER_API void CalculateSphericalCoordinate(const FVector& TargetLocation, const FVector& SourceLocation, const FVector& ForwardDirection,
617  float& OutTargetAzimuthAngle, float& OutTargetAltitudeAngle);
618 
619  //================ Calculate 3D bounding box ================
620  /// Get the mesh's bound cuboid using axis-aligned bounding box
621  NVSCENECAPTURER_API FNVCuboidData GetMeshCuboid_AABB(const class UMeshComponent* MeshComp);
622 
623  /// Get the mesh's bound cuboid using object-oriented bounding box
624  /// NOTE: This 'simple' approach calculate the mesh's AABB in its local space then transform it using the component's local-to-world transform
625  /// @param bInWorldSpace if true, the result is location in world space, otherwise it's in the mesh's local space
626  /// @param bCheckMeshCollision If true, the function check the mesh's collision vertices when finding the bounding box instead of just checking all of its vertices
627  NVSCENECAPTURER_API FNVCuboidData GetMeshCuboid_OOBB_Simple(const class UMeshComponent* MeshComp, bool bInWorldSpace = true, bool bCheckMeshCollision = true);
628 
629  /// Get the mesh's bound cuboid using object-oriented bounding box
630  /// NOTE: This 'complex' approach calculate the OOBB base on 'Principal Component Analysis':
631  /// http://www.inf.fu-berlin.de/users/rote/Papers/pdf/On+the+bounding+boxes+obtained+by+principal+component+analysis.pdf
632  NVSCENECAPTURER_API FNVCuboidData GetMeshCuboid_OOBB_Complex(const class UMeshComponent* MeshComp);
633 
634  NVSCENECAPTURER_API FNVCuboidData GetActorCuboid_AABB(const AActor* CheckActor);
635  NVSCENECAPTURER_API FNVCuboidData GetActorCuboid_OOBB_Simple(const AActor* CheckActor, bool bCheckMeshCollision = true);
636  NVSCENECAPTURER_API FNVCuboidData GetActorCuboid_OOBB_Complex(const AActor* CheckActor);
637 };
Name of parameters that used in message format FText.
Data to be captured and exported for each socket.