RRActorCommon.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// !NOTE: THIS FILE IS THE CORE INCLUDED FILE, THUS IT IS HIGHLY NON-RECOMMENDED TO INCLUDE OTHER FILES HERE-IN TO AVOID CYCLIC
 
// INCLUSION.
 
#include "CoreMinimal.h"
 
 
 
// Native
 
#include <mutex>
 
 
 
// UE
 
#include "Engine.h"
 
#include "Math/Color.h"
 
#include "Misc/Paths.h"
 
 
 
// rclUE
 
#include "logUtilities.h"
 
 
 
// RapyutaSimulationPlugins
 
#include "RapyutaSimulationPlugins.h"
 
 
 
#include "RRActorCommon.generated.h"
 
 
 
#define RAPYUTA_SIM_VERBOSE (0)    // todo make this CVar
 
 
 
 
#define RAPYUTA_SIM_DEBUG (0)
 
#define RAPYUTA_SIM_VISUAL_DEBUG (0)
 
 
 
#define RAPYUTA_USE_SCENE_DIRECTOR (0)
 
 
 
#define RAPYUTA_RUNTIME_MESH_ENTITY_USE_STATIC_MESH (1)
 
#define RAPYUTA_RUNTIME_MESH_ENTITY_USE_PROCEDURAL_MESH (!RAPYUTA_RUNTIME_MESH_ENTITY_USE_STATIC_MESH)
 
 
 
class ARRGameState;
 
class ARRMeshActor;
 
class ARRMeshActor;
 
class ARRCamera;
 
class URRCoreUtils;
 
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRStreamingLevelInfo
 
{
 
 
 
 
    FString AssetPath;
 
 
 
 
    FTransform TargetTransform = FTransform::Identity;
 
 
 
    bool IsValid() const
 
    {
 
        return !AssetPath.IsEmpty();
 
    }
 
 
 
    void PrintSelf() const
 
    {
 
        UE_LOG_WITH_INFO(LogTemp, Log, TEXT("- AssetPath: %s"), *AssetPath);
 
        UE_LOG_WITH_INFO(LogTemp, Log, TEXT("- TargetTransform: %s"), *TargetTransform.ToString());
 
    }
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRAsyncJob
 
{
 
    template<typename TResult>
 
    struct RAPYUTASIMULATIONPLUGINS_API FRRSingleAsyncTask
 
    {
 
 
        TFuture<TResult> Task;
 
 
 
        bool DoneStatus = false;
 
 
 
        FRRSingleAsyncTask()
 
        {
 
        }
 
 
 
 
        FRRSingleAsyncTask(TFuture<TResult>&& InAsyncTask) : Task(MoveTemp(InAsyncTask))
 
        {
 
        }
 
 
 
 
        FRRSingleAsyncTask(FRRSingleAsyncTask&& Other)
 
        {
 
            *this = MoveTemp(Other);
 
        }
 
 
 
        FRRSingleAsyncTask& operator=(FRRSingleAsyncTask&& Other)
 
        {
 
            Task = MoveTemp(Other.Task);
 
            Other.Task.Reset();
 
 
 
            DoneStatus = Other.DoneStatus;
 
            Other.DoneStatus = false;
 
            return *this;
 
        }
 
    };
 
 
 
    explicit FRRAsyncJob(const FString& InJobName) : JobName(InJobName)
 
    {
 
    }
 
    FRRAsyncJob(FRRAsyncJob&& Other)
 
    {
 
        verify(AsyncTasks.Num() == Other.AsyncTasks.Num());
 
        for (int32 i = 0; i < AsyncTasks.Num(); ++i)
 
        {
 
            // This [MoveTemp] would help invoke [FRRSingleAsyncTask] move-ctor!
 
            AsyncTasks[i] = MoveTemp(Other.AsyncTasks[i]);
 
        }
 
        Other.AsyncTasks.Empty();
 
    }
 
 
 
    static constexpr const int8 TASK_INDEX_NONE = -1;
 
 
 
    FString JobName;
 
 
 
 
    uint64 LatestCaptureBatchId = 0;
 
 
 
    TArray<FRRSingleAsyncTask<bool>> AsyncTasks;
 
 
 
    // For the future of UE C++
 
    // TFunction<void(ArgTypes&&...Args)> OnTaskDone;
 
 
 
    int32 GetTasksNum() const
 
    {
 
        return AsyncTasks.Num();
 
    }
 
 
 
 
    void SetAsyncTaskAtLast(TFuture<bool>&& InAsyncTask)
 
    {
 
        verify(AsyncTasks.Num());
 
        AsyncTasks.Last().Task = MoveTemp(InAsyncTask);
 
    }
 
 
 
    void AddAsyncTask(const uint64 InCaptureBatchId, TFuture<bool>&& InAsyncTask)
 
    {
 
        LatestCaptureBatchId = InCaptureBatchId;
 
        AsyncTasks.Emplace(MoveTemp(InAsyncTask));
 
    }
 
 
 
    void AddDefaultAsyncTask()
 
    {
 
        AsyncTasks.Emplace(FRRSingleAsyncTask<bool>());
 
    }
 
 
 
    void Clear()
 
    {
 
        AsyncTasks.Reset();
 
        LatestCaptureBatchId = 0;
 
    }
 
 
 
    void MarkSingleTaskAsDone(int32 TaskIndex, const FString& TaskName)
 
    {
 
        if (TASK_INDEX_NONE == TaskIndex)
 
        {
 
            return;
 
        }
 
 
 
        if (AsyncTasks.IsValidIndex(TaskIndex))
 
        {
 
            AsyncTasks[TaskIndex].DoneStatus = true;
 
#if RAPYUTA_SIM_DEBUG
 
            UE_LOG_WITH_INFO(LogTemp, Display, TEXT("[%s] Async Task done [%d]/[%d]!"), *TaskName, (TaskIndex + 1), GetTasksNum());
 
#endif
 
        }
 
        else
 
        {
 
            UE_LOG_WITH_INFO(
 
                LogTemp, Error, TEXT("[%s] FRRAsyncJob Invalid Async Task Index: %d/%d"), *TaskName, TaskIndex, GetTasksNum());
 
        }
 
    }
 
 
 
    bool IsDone() const
 
    {
 
        for (const auto& asyncTask : AsyncTasks)
 
        {
 
            if (!asyncTask.DoneStatus)
 
            {
 
                return false;
 
            }
 
        }
 
        return true;
 
    }
 
 
 
    void WaitUntilCompleted()
 
    {
 
        for (const auto& asyncTask : AsyncTasks)
 
        {
 
            asyncTask.Task.Get();
 
        }
 
    }
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRHomoMeshEntityGroup
 
{
 
    FRRHomoMeshEntityGroup()
 
    {
 
    }
 
 
 
    FRRHomoMeshEntityGroup(TArray<ARRMeshActor*> InEntities) : Entities(MoveTemp(InEntities))
 
    {
 
    }
 
 
 
 
    TArray<ARRMeshActor*> Entities;
 
 
 
 
    TArray<AActor*> GetActors() const
 
    {
 
        TArray<AActor*> actors;
 
        for (auto& entity : Entities)
 
        {
 
            actors.Add((AActor*)entity);
 
        }
 
        return actors;
 
    }
 
 
 
 
    ARRMeshActor* operator[](int32 Index) const
 
    {
 
        return Entities[Index];
 
    }
 
 
 
 
    int32 Num() const
 
    {
 
        return Entities.Num();
 
    }
 
 
    FString GetGroupModelName() const;
 
 
 
 
    FString GetGroupName() const;
 
};
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRREntityLogInfo
 
{
 
 
 
    //  NOTE: CustomDepthStencilValue, being used as segmaskid, is inherent to each meshcomp & assign once at creation
 
    // & kept unchanged thus could be fetched directly from [Entity] at the logging moment
 
    FRREntityLogInfo()
 
    {
 
    }
 
 
 
    FRREntityLogInfo(TArray<AActor*> InEntities,
 
                     const FString& InGroupModelName,
 
                     const FString& InGroupName,
 
                     const FString& InSegMaskDepthStencilStr,
 
                     const uint64 InSceneId)
 
        : Entities(MoveTemp(InEntities)),
 
          GroupModelName(InGroupModelName),
 
          GroupName(InGroupName),
 
          SegMaskDepthStencilStr(InSegMaskDepthStencilStr),
 
          SceneId(InSceneId)
 
    {
 
    }
 
 
 
 
    TArray<AActor*> Entities;
 
 
 
 
 
    FString GroupModelName;
 
 
 
 
 
    FString GroupName;
 
 
 
 
 
    FString SegMaskDepthStencilStr;
 
 
 
 
 
    uint64 SceneId = 0;
 
 
 
 
 
    FTransform WorldTransform = FTransform::Identity;
 
 
 
 
 
    TArray<FVector> BBVertices3DInWorld;
 
 
 
 
 
    TArray<FVector> BBVertices3DInCamera;
 
 
 
 
 
    TArray<FVector2D> BBVertices2D;
 
};
 
 
 
template<int8 InBitDepth>
 
using FRRColor = typename TChooseClass<(8 == InBitDepth),
 
                                       FColor,
 
                                       typename TChooseClass<(16 == InBitDepth), FFloat16Color, FLinearColor>::Result>::Result;
 
 
 
// (NOTE) TImagePixelData could be used instead
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRColorArray
 
{
 
 
 
 
    TArray<FColor> Colors;
 
 
 
 
    TArray<FFloat16Color> Float16Colors;
 
 
 
 
    TArray<FLinearColor> Float32Colors;
 
 
 
    template<int8 InBitDepth>
 
    const TArray<FRRColor<InBitDepth>>& GetImageData() const
 
    {
 
        if constexpr (8 == InBitDepth)
 
        {
 
            return Colors;
 
        }
 
        else if constexpr (16 == InBitDepth)
 
        {
 
            return Float16Colors;
 
        }
 
        else if constexpr (32 == InBitDepth)
 
        {
 
            return Float32Colors;
 
        }
 
        else
 
        {
 
            UE_LOG_WITH_INFO(LogRapyutaCore, Fatal, TEXT("unsupported bit-depth [%d]"), InBitDepth);
 
        }
 
    }
 
 
 
    template<int8 InBitDepth>
 
    TArray<FRRColor<InBitDepth>>& ImageData()
 
    {
 
        return *const_cast<TArray<FRRColor<InBitDepth>>*>(&GetImageData<InBitDepth>());
 
    }
 
 
 
    FORCEINLINE int64 Num(int8 InBitDepth) const
 
    {
 
        switch (InBitDepth)
 
        {
 
            case 8:
 
                return GetImageData<8>().Num();
 
            case 16:
 
                return GetImageData<16>().Num();
 
            case 32:
 
                return GetImageData<32>().Num();
 
            default:
 
                UE_LOG_WITH_INFO(LogTemp, Fatal, TEXT("FRRColorArray::Num(): unsupported bit-depth [%d]"), InBitDepth);
 
                return 0;
 
        }
 
    }
 
 
 
    FORCEINLINE bool HasData(int8 InBitDepth) const
 
    {
 
        return (Num(InBitDepth) > 0);
 
    }
 
 
 
    void ToggleAlpha(int8 InBitDepth, bool bAlphaEnabled)
 
    {
 
        switch (InBitDepth)
 
        {
 
            case 8:
 
                for (auto& color : ImageData<8>())
 
                {
 
                    color.A = bAlphaEnabled ? FColor::Black.A : FColor::Transparent.A;
 
                }
 
                break;
 
            case 16:
 
                for (auto& color : ImageData<16>())
 
                {
 
                    color.A = bAlphaEnabled ? FLinearColor::Black.A : FLinearColor::Transparent.A;
 
                }
 
                break;
 
            case 32:
 
                for (auto& color : ImageData<32>())
 
                {
 
                    color.A = bAlphaEnabled ? FLinearColor::Black.A : FLinearColor::Transparent.A;
 
                }
 
                break;
 
            default:
 
                UE_LOG_WITH_INFO(LogRapyutaCore, Fatal, TEXT("unsupported bit-depth [%d]"), InBitDepth);
 
                break;
 
        }
 
    }
 
};
 
 
 
 
struct RAPYUTASIMULATIONPLUGINS_API FRRActorSpawnInfo
 
{
 
 
 
    FRRActorSpawnInfo();
 
    FRRActorSpawnInfo(const FString& InEntityModelName,
 
                      const FString& InUniqueName,
 
                      const FTransform& InActorTransform,
 
                      const TArray<FTransform>& InMeshRelTransformList = TArray<FTransform>(),
 
                      const TArray<FString>& InMeshUniqueNameList = TArray<FString>(),
 
                      const TArray<FString>& InMaterialNameList = TArray<FString>(),
 
                      bool bInIsStationary = false,
 
                      bool bInIsPhysicsEnabled = false,
 
                      bool bInIsCollisionEnabled = false,
 
                      bool bInIsOverlapEventEnabled = false);
 
 
 
    void operator()(const FString& InEntityModelName,
 
                    const FString& InUniqueName,
 
                    const FTransform& InActorTransform = FTransform::Identity,
 
                    const TArray<FTransform>& InMeshRelTransformList = TArray<FTransform>(),
 
                    const TArray<FString>& InMeshUniqueNameList = TArray<FString>(),
 
                    const TArray<FString>& InMaterialNameList = TArray<FString>(),
 
                    bool bInIsStationary = false,
 
                    bool bInIsPhysicsEnabled = false,
 
                    bool bInIsCollisionEnabled = false,
 
                    bool bInIsOverlapEventEnabled = false);
 
 
 
    void ClearMeshInfo()
 
    {
 
        MeshUniqueNameList.Reset();
 
        MeshRelTransformList.Reset();
 
        MaterialNameList.Reset();
 
    }
 
 
 
 
    FString EntityModelName;
 
 
 
    FString UniqueName;
 
 
 
 
    FTransform ActorTransform = FTransform::Identity;
 
 
 
 
    TArray<FTransform> MeshRelTransformList;
 
 
 
 
    TArray<FString> MeshUniqueNameList;
 
 
 
 
    TArray<FString> MaterialNameList;
 
 
 
 
    uint8 bIsTickEnabled : 1;
 
 
 
 
    uint8 bIsStationary : 1;
 
 
 
 
    uint8 bIsPhysicsEnabled : 1;
 
 
 
 
    uint8 bIsCollisionEnabled : 1;
 
 
 
 
    uint8 bIsSelfCollision : 1;
 
 
 
 
    uint8 bIsOverlapEventEnabled : 1;
 
 
 
 
    uint8 bIsDataSynthEntity : 1;
 
 
 
    // Spawn Configuration Info --
 
    // [MeshComList] now belongs to [ARRMeshActor], only which SpawnSimActor<T> spawns
 
 
    TSubclassOf<AActor> TypeClass = nullptr;
 
 
 
    bool IsValid(bool bIsLogged = false) const
 
    {
 
        return (false == EntityModelName.IsEmpty());
 
    }
 
};
 
 
 
DECLARE_DELEGATE_TwoParams(FOnMeshActorFullyCreated, bool /* bCreationResult */, ARRMeshActor*);
 
 
 
class RAPYUTASIMULATIONPLUGINS_API URRActorCommon : public UObject
 
{
 
 
 
 
    friend class URRCoreUtils;
 
 
 
private:
 
    static TMap<int8, URRActorCommon*> SActorCommonList;
 
 
 
public:
 
    static constexpr int8 DEFAULT_SCENE_INSTANCE_ID = 0;
 
    static URRActorCommon* GetActorCommon(int8 InSceneInstanceId = URRActorCommon::DEFAULT_SCENE_INSTANCE_ID,
 
                                          UClass* ActorCommonClass = nullptr,
 
                                          UObject* Outer = nullptr);
 
    URRActorCommon();
 
    static constexpr const TCHAR* SCRIPT_INI_PATH = TEXT("/Script/RapyutaSimulationPlugins.RRActorCommon");
 
    static std::once_flag OnceFlag;
 
 
 
    static void OnPostWorldCleanup(UWorld* InWorld, bool /*bInSessionEnded*/, bool /*bInCleanupResources*/);
 
 
 
public:
 
    static constexpr const TCHAR* SPACE_STR = TEXT(" ");
 
    static constexpr const TCHAR* DELIMITER_STR = TEXT(",");
 
    static constexpr const TCHAR* UNDERSCORE_STR = TEXT("_");
 
    static constexpr const char* NAN_STR = "NaN";
 
    static const std::string QUOTED_NAN_STR;
 
    static constexpr const char* NONE_STR = "None";    // or NAME_None ?
 
    static constexpr const char* NULL_STR = "Null";
 
    static const std::string QUOTED_NULL_STR;
 
    static constexpr const char* DOUBLE_QUOTE_CHAR = "\"";
 
 
 
    static constexpr int32 SIM_SCENE_COMPLETION_TIMEOUT_SECS = 10;
 
 
 
    static constexpr int8 IMAGE_BIT_DEPTH_INT8 = 8;
 
    static constexpr int8 IMAGE_BIT_DEPTH_FLOAT16 = 16;
 
    static constexpr int8 IMAGE_BIT_DEPTH_FLOAT32 = 32;
 
 
 
    static constexpr const TCHAR* MAP_ORIGIN_TAG = TEXT("map_origin");
 
    static constexpr const TCHAR* MAP_ROS_FRAME_ID = TEXT("map");
 
 
 
 
 
    int8 SceneInstanceId = DEFAULT_SCENE_INSTANCE_ID;
 
 
 
 
 
    FVector SceneInstanceLocation = FVector::ZeroVector;
 
 
 
 
 
    static uint64 SLatestSceneId;
 
    FORCEINLINE static uint64 GetNextSceneId()
 
    {
 
        return ++SLatestSceneId;
 
    }
 
 
 
 
 
    uint64 CurrentSceneId = 0;
 
 
 
 
 
    AActor* SceneFloor = nullptr;
 
 
 
 
 
 
    AActor* SceneWall = nullptr;
 
 
 
 
 
    ARRCamera* SceneCamera = nullptr;
 
 
 
 
    TArray<ALight*> MainLights;
 
 
 
 
    virtual void PrintSimConfig() const;
 
 
 
 
    virtual void OnStartSim();
 
 
 
 
    virtual void OnBeginPlay()
 
    {
 
    }
 
 
 
 
    virtual void OnEndPlay(const EEndPlayReason::Type EndPlayReason)
 
    {
 
    }
 
 
 
    virtual bool HasInitialized(bool bIsLogged = false) const;
 
 
    virtual void SetupEnvironment();
 
 
 
 
 
    FOnMeshActorFullyCreated OnMeshActorFullyCreated;
 
 
 
    // NOTE:
 
    // + Currently UE only supports [0-255] CustomDepthStencil values,
 
    // which might probably be extended to a larger range then.
 
    // + Since deactivated actors do not appear in scene so their custom depth stencil values should be reused
 
    // for activated ones in any scene instance.
 
    // + Also, actors of different scene instances, due to always appearing in different scenes, could share the same value,
 
    // thus each scene instance must have its own [LatestCustomDepthStencilValue]
 
 
 
    // Temp as No of non-zero elements in [DATA_SYNTH_CUSTOM_DEPTH_STENCILS], due to UE5 segmask mismatch issue
 
    static constexpr int16 MAX_CUSTOM_DEPTH_STENCIL_VALUES_NUM = 76;
 
    static constexpr int8 DEFAULT_CUSTOM_DEPTH_STENCIL_VALUE_VOID = 0;
 
 
 
 
 
    static TArray<int32> StaticCustomDepthStencilList;
 
 
 
 
    int32 LatestCustomDepthStencilValue = 0;
 
 
 
 
    int32 GenerateUniqueDepthStencilValue()
 
    {
 
        if (LatestCustomDepthStencilValue > MAX_CUSTOM_DEPTH_STENCIL_VALUES_NUM)
 
        {
 
            UE_LOG_WITH_INFO(LogTemp,
 
                             Error,
 
                             TEXT("SceneInstance[%d] [%d] More than %d CustomDepthStencil values having been assigned!"
 
                                  "Segmentation Mask will be duplicated!"),
 
                             SceneInstanceId,
 
                             LatestCustomDepthStencilValue,
 
                             MAX_CUSTOM_DEPTH_STENCIL_VALUES_NUM);
 
        }
 
 
 
        // Fetch the next non-static [CustomDepthStencilValue]
 
        do
 
        {
 
            ++LatestCustomDepthStencilValue;
 
        } while (StaticCustomDepthStencilList.Contains(LatestCustomDepthStencilValue));
 
        return LatestCustomDepthStencilValue;
 
    }
 
};
 
 
 
class ARRSceneDirector;
 
class ARRPlayerController;
 
 
 
class RAPYUTASIMULATIONPLUGINS_API URRSceneInstance : public UObject
 
{
 
public:
 
    virtual void ConfigureStaticClasses();
 
 
 
    virtual bool IsValid(bool bIsLogged = false) const;
 
 
 
 
    ARRPlayerController* PlayerController = nullptr;
 
 
 
    // Sim Common --
 
 
    TSubclassOf<URRActorCommon> ActorCommonClass;
 
 
 
 
    URRActorCommon* ActorCommon = nullptr;
 
 
 
    // Scene Director --
 
 
    TSubclassOf<ARRSceneDirector> SceneDirectorClass;
 
 
 
 
    ARRSceneDirector* SceneDirector = nullptr;
 
};