RRBaseRobot.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// UE
 
#include "Components/StaticMeshComponent.h"
 
#include "Components/WidgetComponent.h"
 
#include "CoreMinimal.h"
 
 
 
// rclUE
 
#include "ROS2NodeComponent.h"
 
 
 
// RapyutaSimulationPlugins
 
#include "Core/RRBaseActor.h"
 
#include "Core/RRObjectCommon.h"
 
#include "Drives/RRJointComponent.h"
 
#include "Drives/RobotVehicleMovementComponent.h"
 
#include "Sensors/RRROS2BaseSensorComponent.h"
 
#include "Tools/ROS2Spawnable.h"
 
#include "Tools/RRUIWidgetComponent.h"
 
 
 
#include "RRBaseRobot.generated.h"
 
 
 
#define RR_VERIFY_DYNAMIC_ROBOT(InRobot)                                                                                  \
 
    if (InRobot && (false == InRobot->IsDynamicRuntimeRobot()))                                                           \
 
    {                                                                                                                     \
 
        UE_LOG_WITH_INFO(LogTemp,                                                                                         \
 
                         Error,                                                                                           \
 
                         TEXT("[ClassName:%s] is required to be NOT prefixed with [BP_] or [SKEL_BP] if this is purely a" \
 
                              "cpp-based robot class!"),                                                                  \
 
                         *InRobot->GetClass()->GetName());                                                                \
 
    }
 
 
 
#define RR_VERIFY_STATIC_BP_ROBOT(InRobot)                                                                                 \
 
    if (InRobot && (false == InRobot->IsStaticBPRobot()))                                                                  \
 
    {                                                                                                                      \
 
        UE_LOG_WITH_INFO(LogTemp,                                                                                          \
 
                         Error,                                                                                            \
 
                         TEXT("[ClassName:%s] is required to be prefixed with [BP_] if this is a blueprint robot class!"), \
 
                         *InRobot->GetClass()->GetName());                                                                 \
 
    }
 
 
 
#define RR_VERIFY_DYNAMIC_OR_STATIC_BP_ROBOT(InRobot) \
 
    {                                                 \
 
    }
 
 
 
class ARRNetworkGameState;
 
class URRRobotROS2Interface;
 
class ARRNetworkPlayerController;
 
class URRUserWidget;
 
 
 
enum class ERRNetworkAuthorityType : uint8
 
{
 
    SERVER , 
 
    CLIENT , 
 
};
 
 
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnRobotCreationDone, bool /* bCreationResult */);
 
 
 
class RAPYUTASIMULATIONPLUGINS_API ARRBaseRobot : public ARRBaseActor
 
{
 
 
 
public:
 
    ARRBaseRobot();
 
 
 
    ARRBaseRobot(const FObjectInitializer& ObjectInitializer);
 
 
 
    virtual void BeginPlay() override;
 
 
 
    virtual void Tick(float DeltaSeconds) override;
 
 
 
    void SetupDefault();
 
 
 
 
    TObjectPtr<USceneComponent> DefaultRoot = nullptr;
 
 
 
    virtual void SetRootOffset(const FTransform& InRootOffset);
 
 
 
    FORCEINLINE bool IsDynamicRuntimeRobot() const
 
    {
 
        return (false == IsStaticBPRobot());
 
    }
 
 
 
    FORCEINLINE bool IsStaticBPRobot() const
 
    {
 
        // NOTE: (GetClass()->ClassGeneratedBy != nullptr) is also useful but WITH_EDITORONLY_DATA
 
        const FString className = GetClass()->GetName();
 
        return className.StartsWith(TEXT("BP"))             // In-Editor
 
               || className.StartsWith(TEXT("SKEL_BP"));    // In-Package auto prefixed [SKEL_]
 
    }
 
 
 
    FString GetDynamicResourceName(const ERRResourceDataType InDataType) const;
 
 
 
    FString GetDynamicResourceAssetPath(const ERRResourceDataType InDataType) const;
 
 
 
 
    FOnRobotCreationDone OnRobotCreationDone;
 
 
 
 
 
    TSubclassOf<URRRobotROS2Interface> ROS2InterfaceClass = nullptr;
 
 
 
    TObjectPtr<URRRobotROS2Interface> ROS2Interface = nullptr;
 
 
 
    virtual void OnRep_ROS2Interface();
 
 
 
    bool bStartStopROS2Interface = false;
 
 
 
    virtual void OnRep_bStartStopROS2Interface();
 
 
 
    bool IsAuthorizedInThisClient();
 
 
 
 
 
 
 
    TObjectPtr<UROS2Spawnable> ROSSpawnParameters = nullptr;
 
 
 
    TObjectPtr<ARRBaseRobot> ServerRobot = nullptr;
 
 
 
    void CreateROS2Interface();
 
 
 
    void InitROS2Interface();
 
 
 
 
    bool InitROS2InterfaceImpl();
 
 
 
 
    FTimerHandle ROS2InitTimer;
 
 
 
    void DeInitROS2Interface();
 
 
 
    FString RobotUniqueName;
 
 
 
    void SetRobotName(const FString& InRobotName)
 
    {
 
        RobotUniqueName = InRobotName;
 
        EntityUniqueName = InRobotName;
 
    }
 
 
 
 
 
 
 
    FString RobotModelName;
 
 
 
 
    virtual void SetRobotModelName(const FString InName)
 
    {
 
        RobotModelName = InName;
 
        EntityModelName = InName;
 
        if (ActorInfo.IsValid())
 
        {
 
            ActorInfo->EntityModelName = InName;
 
        }
 
    }
 
 
 
 
    virtual FString GetRobotModelName()
 
    {
 
        return RobotModelName;
 
    }
 
 
 
    FORCEINLINE bool IsBuiltInRobotModel() const
 
    {
 
        return RobotModelName.StartsWith(TEXT("UE"), ESearchCase::IgnoreCase);
 
    }
 
 
 
 
 
    uint64 RobotID = 0;
 
 
 
    uint64 GetRobotID() const
 
    {
 
        return RobotID;
 
    }
 
 
 
    void SetRobotID(uint64 InRobotID)
 
    {
 
        RobotID = InRobotID;
 
    }
 
 
 
    TMap<FString, UStaticMeshComponent*> Links;
 
 
 
    virtual bool AddLink(const FString& InLinkName, UStaticMeshComponent* InMesh);
 
 
 
 
 
    TObjectPtr<UMeshComponent> BaseMeshComp = nullptr;
 
 
 
    void SetBaseMeshComp(UMeshComponent* InBaseMeshComp, bool bInMakeAsRoot = true, bool bInDestroyDefaultRoot = true);
 
 
 
    TMap<FString, URRJointComponent*> Joints;
 
 
 
    virtual bool AddJoint(const FString& InParentLinkName,
 
                          const FString& InChildLinkName,
 
                          const FString& InJointName,
 
                          URRJointComponent* InJoint);
 
 
 
    bool bInitializeJoints = true;
 
 
 
 
    virtual void StartJointsInitialization();
 
 
 
 
    virtual void CheckJointsInitialization();
 
 
 
    virtual void SetChildComponentsCollisionEnabled(const bool IsEnable);
 
 
 
    virtual bool InitSensors(UROS2NodeComponent* InROS2Node);
 
 
 
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
 
 
 
    virtual bool ReplicateSubobjects(UActorChannel* Channel, FOutBunch* Bunch, FReplicationFlags* RepFlags) override;
 
 
 
    // UFUNCTION(BlueprintCallable)
 
    virtual void SetJointState(const TMap<FString, TArray<float>>& InJointState, const ERRJointControlType InJointControlType);
 
 
 
    ERRNetworkAuthorityType NetworkAuthorityType = ERRNetworkAuthorityType::CLIENT;
 
 
 
    // MOVEMENT --
 
    //
 
 
 
    FVector TargetLinearVel = FVector::ZeroVector;
 
 
 
 
 
    FVector TargetAngularVel = FVector::ZeroVector;
 
 
 
    virtual void StopMovement();
 
 
 
 
 
 
    TObjectPtr<UMovementComponent> MovementComponent = nullptr;
 
 
 
 
 
 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Instanced, Replicated)
 
 
    TObjectPtr<URobotVehicleMovementComponent> RobotVehicleMoveComponent;
 
 
 
 
 
 
    TSubclassOf<UMovementComponent> VehicleMoveComponentClass;
 
 
 
 
    virtual void SetMoveComponent(UMovementComponent* InMoveComponent);
 
 
 
    virtual void SetLinearVel(const FVector& InLinearVel);
 
 
 
    virtual void SetAngularVel(const FVector& InAngularVel);
 
 
 
    virtual void SyncServerLinearMovement(float InClientTimeStamp,
 
                                          const FTransform& InClientRobotTransform,
 
                                          const FVector& InLinearVel);
 
 
 
    virtual void SyncServerAngularMovement(float InClientTimeStamp,
 
                                           const FRotator& InClientRobotRotation,
 
                                           const FVector& InAngularVel);
 
 
 
    virtual void SetLocalLinearVel(const FVector& InLinearVel);
 
 
 
    virtual void SetLocalAngularVel(const FVector& InAngularVel);
 
 
 
 
 
    FTransform RootOffset = FTransform::Identity;
 
 
 
 
 
    bool bInitRobotVehicleMoveComponent = true;
 
 
 
    void BPConfigureMovementComponent();
 
 
 
 
 
    bool bMobileRobot = true;
 
 
 
 
 
    bool bJointControl = true;
 
 
 
    // UI WIDGET --
 
 
 
    uint8 bUIWidgetEnabled : 1;
 
 
 
 
 
    TObjectPtr<URRUIWidgetComponent> UIWidgetComp = nullptr;
 
 
 
 
 
    FTransform UIWidgetOffset = FTransform(FVector(0.f, 0.f, 100.f));
 
 
 
 
 
    TSubclassOf<UUserWidget> UIUserWidgetClass;
 
 
 
    bool CheckUIUserWidget() const;
 
 
 
protected:
 
    virtual void PreInitializeComponents() override;
 
 
 
    virtual void PostInitializeComponents() override;
 
 
 
    virtual bool InitMoveComponent();
 
 
 
    void BPPreInitializeComponents();
 
 
 
    void BPPostInitializeComponents();
 
 
 
public:
 
    virtual bool InitPropertiesFromJSON();
 
 
 
    void BPInitPropertiesFromJSON();
 
 
 
    virtual void ConfigureMovementComponent();
 
 
 
    virtual void InitUIWidget();
 
 
 
    bool bInitializingJoints = false;
 
 
 
    TMap<UPrimitiveComponent*, FName> OriginalCollisionProfiles;
 
 
 
 
    virtual bool InitPropertiesFromJSONAll()
 
    {
 
        bool res = InitPropertiesFromJSON();
 
        BPInitPropertiesFromJSON();
 
        return res;
 
    };
 
};