ActorInstanceHandle.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/WeakInterfacePtr.h"
#include "ActorInstanceHandle.generated.h"
 
class USceneComponent;
class AActor;
class UActorInstanceManager;
class IActorInstanceManagerInterface;
class ULevel;
 
using FActorInstanceManagerInterface = TWeakInterfacePtr<IActorInstanceManagerInterface>;
 
USTRUCT(BlueprintType)
struct FActorInstanceHandle
{
    GENERATED_BODY()
 
    FActorInstanceHandle() = default;
 
    ENGINE_API explicit FActorInstanceHandle(AActor* InActor);
    ENGINE_API FActorInstanceHandle(const UPrimitiveComponent* RelevantComponent, int32 CollisionInstanceIndex);
    ENGINE_API FActorInstanceHandle(AActor* InActor, const UPrimitiveComponent* RelevantComponent, int32 CollisionInstanceIndex);
    ENGINE_API FActorInstanceHandle(FActorInstanceManagerInterface InManagerInterface, int32 InstanceIndex);
    ENGINE_API FActorInstanceHandle(const FActorInstanceHandle& Other);
 
    static ENGINE_API FActorInstanceHandle MakeDehydratedActorHandle(UObject& Manager, int32 InInstanceIndex);
 
    static ENGINE_API FActorInstanceHandle MakeActorHandleToResolve(const TWeakObjectPtr<UPrimitiveComponent>& WeakComponent, int32 CollisionInstanceIndex);
 
    ENGINE_API bool IsValid() const;
 
    UE_DEPRECATED(5.8, "Detecting the ResolutionStatus of the pointer will be removed in a future release.")
    ENGINE_API bool IsUnresolvedDehydratedActor() const;
 
    ENGINE_API bool DoesRepresentClass(const UClass* OtherClass) const;
 
    template<typename T>
    bool DoesRepresent() const;
 
    ENGINE_API UClass* GetRepresentedClass() const;
    ENGINE_API ULevel* GetLevel() const;
    ENGINE_API FVector GetLocation() const;
    ENGINE_API FRotator GetRotation() const;
    ENGINE_API FTransform GetTransform() const;
 
    ENGINE_API FName GetFName() const;
    ENGINE_API FString GetName() const;
 
    ENGINE_API AActor* GetManagingActor() const;
 
    ENGINE_API USceneComponent* GetRootComponent() const;
 
    ENGINE_API AActor* FetchActor() const;
 
    template <typename T>
    T* FetchActor() const;
 
    ENGINE_API AActor* GetCachedActor() const;
    ENGINE_API void SetCachedActor(AActor* InActor) const;
 
    /* Returns the index used internally by the manager */
    inline int32 GetInstanceIndex() const { return InstanceIndex; }
 
    FActorInstanceHandle& operator=(const FActorInstanceHandle& Other) = default;
    FActorInstanceHandle& operator=(FActorInstanceHandle&& Other) = default;
    ENGINE_API FActorInstanceHandle& operator=(AActor* OtherActor);
 
    ENGINE_API bool operator==(const FActorInstanceHandle& Other) const;
    ENGINE_API bool operator!=(const FActorInstanceHandle& Other) const;
 
    ENGINE_API bool operator==(const AActor* OtherActor) const;
    ENGINE_API bool operator!=(const AActor* OtherActor) const;
 
    explicit operator bool() const { return IsValid(); }
 
    friend ENGINE_API uint32 GetTypeHash(const FActorInstanceHandle& Handle);
 
    friend ENGINE_API FArchive& operator<<(FArchive& Ar, FActorInstanceHandle& Handle);
 
    FActorInstanceManagerInterface GetManagerInterface() const { return ManagerInterface; }
 
    template<typename T>
    T* GetManager() const 
    {
        return Cast<T>(ManagerInterface.GetObject());
    }
 
private:
    friend struct FActorInstanceHandleInternalHelper;
 
    UObject* GetActorAsUObject();
    const UObject* GetActorAsUObject() const;
 
    bool IsActorValid() const;
 
    void ResolveHandle() const;
    
    UPROPERTY()
    mutable TWeakObjectPtr<UObject> ReferenceObject;
 
    FActorInstanceManagerInterface ManagerInterface;
 
    int32 InstanceIndex = INDEX_NONE;
 
    enum class EResolutionStatus : uint8
    {
        Invalid,
        Resolved, /* ManagerInterface and InstanceIndex are set or an Actor pointer is stored in ReferenceObject */
        NeedsResolving /* Component pointer is stored in ReferenceObject and InstanceIndex might hold a CollisionInstanceIndex */
    };
 
    EResolutionStatus ResolutionStatus = EResolutionStatus::Invalid;
};
 
template<typename T>
bool FActorInstanceHandle::DoesRepresent() const
{
    if (const UClass* RepresentedClass = GetRepresentedClass())
    {
        if constexpr (TIsIInterface<T>::Value)
        {
            return RepresentedClass->ImplementsInterface(T::UClassType::StaticClass());
        }
        else
        {
            return RepresentedClass->IsChildOf(T::StaticClass());
        }
    }
    return false;
}
 
template <typename T>
T* FActorInstanceHandle::FetchActor() const
{
    if (DoesRepresent<T>())
    {
        return CastChecked<T>(FetchActor(), ECastCheckedType::NullAllowed);
    }
    return nullptr;
}