RRMeshActor.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// RapyutaSimulationPlugins
 
#include "Core/RRBaseActor.h"
 
#include "Core/RRCoreUtils.h"
 
#include "Core/RRProceduralMeshComponent.h"
 
#include "Core/RRStaticMeshComponent.h"
 
#include "Core/RRUObjectUtils.h"
 
#include "RapyutaSimulationPlugins.h"
 
 
 
#include "RRMeshActor.generated.h"
 
 
 
DECLARE_DELEGATE_OneParam(FOnMeshActorDeactivated, ARRMeshActor*);
 
 
 
class RAPYUTASIMULATIONPLUGINS_API ARRMeshActor : public ARRBaseActor
 
{
 
public:
 
    ARRMeshActor();
 
 
 
public:
 
    virtual bool Initialize() override;
 
 
 
    virtual bool HasInitialized(bool bIsLogged = false) const override;
 
 
 
    virtual void Reset() override;
 
    void DrawTransform();
 
 
 
public:
 
 
 
    TArray<UMeshComponent*> MeshCompList;
 
 
 
 
 
    int32 CreatedMeshesNum = 0;
 
 
 
 
 
    int32 ToBeCreatedMeshesNum = 0;
 
 
 
 
 
    TObjectPtr<UMeshComponent> BaseMeshComp = nullptr;
 
 
 
    UMaterialInterface* GetBaseMeshMaterial(int32 InMaterialIndex = 0) const
 
    {
 
        return BaseMeshComp ? BaseMeshComp->GetMaterial(InMaterialIndex) : nullptr;
 
    }
 
 
 
    virtual void DeclareFullCreation(bool bInCreationResult);
 
 
 
public:
 
 
 
    FIntVector CellIdx = FIntVector::ZeroValue;
 
 
 
    UMeshComponent* GetMeshComponent(int32 Index = 0) const;
 
 
 
    template<typename TMeshComp>
 
    TArray<TMeshComp*> CreateMeshComponentList(USceneComponent* InParentComp,
 
                                               const TArray<FString>& InMeshUniqueNameList,
 
                                               const TArray<FTransform>& InMeshRelTransf = TArray<FTransform>(),
 
                                               const TArray<FString>& InMaterialNameList = TArray<FString>())
 
    {
 
        // (Note) This method could be invoked multiple times
 
        TArray<TMeshComp*> addedMeshCompList;
 
        if (InMeshRelTransf.Num() > 0)
 
        {
 
            verify(InMeshRelTransf.Num() == InMeshUniqueNameList.Num());
 
        }
 
        if (InMaterialNameList.Num() > 0)
 
        {
 
            verify(InMaterialNameList.Num() == InMeshUniqueNameList.Num());
 
        }
 
 
 
        TMeshComp* meshComp = nullptr;
 
        for (auto i = 0; i < InMeshUniqueNameList.Num(); ++i)
 
        {
 
            const FString& meshUniqueName = InMeshUniqueNameList[i];
 
 
 
            // [ProcMeshComp] Verify path as absolute & existing
 
            if ((false == FPaths::IsRelative(meshUniqueName)) && (false == FPaths::FileExists(meshUniqueName)))
 
            {
 
                UE_LOG_WITH_INFO(LogTemp, Error, TEXT("Mesh invalid [%s] is non-existent"), *meshUniqueName);
 
                continue;
 
            }
 
 
 
            // [OBJECT MESH COMP] --
 
            //
 
            meshComp = URRUObjectUtils::CreateMeshComponent<TMeshComp>(
 
                this,
 
                meshUniqueName,
 
                FString::Printf(TEXT("%s_MeshComp_%u"), *ActorInfo->UniqueName, MeshCompList.Num()),
 
                InMeshRelTransf.IsValidIndex(i) ? InMeshRelTransf[i] : FTransform::Identity,
 
                ActorInfo->bIsStationary,
 
                ActorInfo->bIsPhysicsEnabled,
 
                ActorInfo->bIsCollisionEnabled,
 
                ActorInfo->bIsOverlapEventEnabled,
 
                InParentComp);
 
 
 
            if (meshComp)
 
            {
 
                // (Note) This must be the full path to the mesh file on disk
 
                if (meshComp->InitializeMesh(meshUniqueName))
 
                {
 
                    addedMeshCompList.AddUnique(meshComp);
 
                }
 
                else
 
                {
 
                    UE_LOG_WITH_INFO_NAMED(LogTemp, Error, TEXT("Failed initializing mesh comp[%s]"), *meshUniqueName);
 
                }
 
            }
 
            else
 
            {
 
                UE_LOG_WITH_INFO(LogTemp,
 
                                 Error,
 
                                 TEXT("[%s:%d] - Failed creating child Mesh Component [%s]!"),
 
                                 *ActorInfo->UniqueName,
 
                                 this,
 
                                 *meshUniqueName);
 
            }
 
 
 
            // [MeshCompList] <- [addedMeshCompList]
 
            MeshCompList.Append(addedMeshCompList);
 
        }
 
 
 
        // Change RootComponent -> BaseMeshComp
 
        if ((nullptr == BaseMeshComp) && (MeshCompList.Num() > 0))
 
        {
 
            BaseMeshComp = MeshCompList[0];
 
 
 
            if (BaseMeshComp->GetRelativeTransform().Equals(FTransform::Identity))
 
            {
 
                // Set as Root Component
 
                // Set the main mesh comp as the root
 
                // (Not clear why using the default scene component as the root just disrupts actor-children relative movement,
 
                // and thus also compromise the actor transform itself)!
 
                USceneComponent* oldRoot = RootComponent;
 
                SetRootComponent(BaseMeshComp);
 
                if (oldRoot)
 
                {
 
                    oldRoot->DestroyComponent();
 
                }
 
            }
 
        }
 
 
 
        return addedMeshCompList;
 
    }
 
 
 
    virtual void OnBodyComponentMeshCreationDone(bool bInCreationResult, UObject* InMeshBodyComponent);
 
 
 
    void SetCustomDepthEnabled(bool bIsCustomDepthEnabled);
 
 
 
    void SetCustomDepthStencilValue(int32 InCustomDepthStencilValue);
 
 
 
    bool IsCustomDepthEnabled() const;
 
 
 
    TArray<int32> GetCustomDepthStencilValueList() const;
 
 
 
 
    FOnMeshActorDeactivated OnDeactivated;
 
 
 
    FORCEINLINE virtual void SetActivated(bool bInIsActivated)
 
    {
 
#if RAPYUTA_SIM_VISUAL_DEBUG
 
        // Visible/Invisibile
 
        SetActorHiddenInGame(!bInIsActivated);
 
#endif
 
 
 
        // Then teleport itself to a camera-blind location if being deactivated,
 
        // so when it get activated back, it would not happen to appear at an unintended pose
 
        if (false == bInIsActivated)
 
        {
 
            CellIdx = FIntVector::NoneValue;
 
            SetActorLocation(FVector(0.f, 0.f, -5000.f));
 
            OnDeactivated.ExecuteIfBound(this);
 
        }
 
        else if (CellIdx == FIntVector::NoneValue)
 
        {
 
            CellIdx = FIntVector::ZeroValue;
 
        }
 
 
 
        // RenderCustomDepth (must be after [OnDeactivated], thus its current CustomDepthStencilValue could be stored)
 
        SetCustomDepthEnabled(bInIsActivated);
 
    }
 
 
 
    bool IsActivated() const
 
    {
 
        return (CellIdx != FIntVector::NoneValue);
 
    }
 
 
 
protected:
 
 
 
    uint8 bLastMeshCreationResult : 1;
 
 
 
 
 
    uint8 bFullyCreated : 1;
 
};