RemoteObject.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "UObject/RemoteObjectTypes.h"
#include "UObject/ObjectMacros.h"
 
class UObject;
class UClass;
 
namespace UE::RemoteObject
{
    UE_DEPRECATED(5.6, "Use FRemoteServerId::GetLocalServerId() instead.")
    UE_FORCEINLINE_HINT FRemoteServerId GetGlobalServerId()
    {
        return FRemoteServerId::GetLocalServerId();
    }
}
 
namespace UE::RemoteObject::Handle
{
    struct FPhysicsIslandId
    {
        friend struct FRemoteObjectId;
 
        FRemoteServerId PhysicsServerId;
 
        //IMPORTANT: LocalIslandIndex = 0 means it's invalid. 
        uint32 PhysicsLocalIslandId = 0;
 
        void Reset();
 
        FPhysicsIslandId() = default;
 
        FPhysicsIslandId(const FRemoteServerId& PhysicsServerIdIn, const uint32 PhysicsLocalIslandIdIn)
            : PhysicsServerId(PhysicsServerIdIn), PhysicsLocalIslandId(PhysicsLocalIslandIdIn)
        {
        }
 
        bool operator==(const FPhysicsIslandId& Other) const
        {
            return PhysicsServerId == Other.PhysicsServerId && PhysicsLocalIslandId == Other.PhysicsLocalIslandId;
        }
 
        bool IsValid() const
        {
            return PhysicsServerId.IsValid() && PhysicsLocalIslandId != INDEX_NONE;
        }
 
        bool operator<(const FPhysicsIslandId& Other) const
        {
            return PhysicsServerId < Other.PhysicsServerId ||
                (PhysicsServerId == Other.PhysicsServerId && PhysicsLocalIslandId < Other.PhysicsLocalIslandId);
        }
 
        bool operator<=(const FPhysicsIslandId& Other) const
        {
            return (*this) < Other || (*this) == Other;
        }
 
        friend FArchive& operator<<(FArchive& Ar, FPhysicsIslandId& ID)
        {
            Ar << ID.PhysicsServerId;
            Ar << ID.PhysicsLocalIslandId;
            return Ar;
        }
 
        FString ToString() const
        {
            return FString::Printf(TEXT("[%s, %d]"), *(PhysicsServerId.ToString()), PhysicsLocalIslandId);
        }
    };
 
    UE_FORCEINLINE_HINT uint32 GetTypeHash(const FPhysicsIslandId& Key)
    {
        // Combine hashes of the members
        return HashCombine(::GetTypeHash(Key.PhysicsServerId.GetIdNumber()), ::GetTypeHash(Key.PhysicsLocalIslandId));
    }
 
    struct FRemoteObjectClass
    {
        UPTRINT PathNameOrClass = 0;
 
        FRemoteObjectClass() = default;
        COREUOBJECT_API explicit FRemoteObjectClass(UClass* InClass);
 
        bool IsNative() const
        {
            return !(PathNameOrClass & 1);
        }
 
        bool IsValid() const
        {
            return !!PathNameOrClass;
        }
        
        COREUOBJECT_API UClass* GetClass() const;
    };
 
    // Structure that holds basic information about a remote object
    // This is what FObjectPtr that references a remote object actually points to after the remote object's memory has been claimed by GC
    struct FRemoteObjectStub
    {
        FRemoteObjectId Id;
        FRemoteObjectId OuterId;
        FName Name;
        FRemoteObjectClass Class;
 
        int32 SerialNumber = 0;
 
        FRemoteServerId ResidentServerId;
 
        FRemoteServerId OwningServerId;
 
        FPhysicsIslandId PhysicsIslandId;
 
        FRemoteObjectStub() = default;
        COREUOBJECT_API explicit FRemoteObjectStub(UObject* Object);
    };
 
    enum class ERemoteReferenceType
    {
        Strong = 0,
        Weak = 1
    };
 
    enum class ERemoteObjectGetClassBehavior
    {
        ReturnNullIfNeverLocal,
 
        MigrateIfNeverLocal,
    };
 
    COREUOBJECT_API UObject* ResolveObject(const FRemoteObjectStub* Stub, ERemoteReferenceType RefType = ERemoteReferenceType::Strong);
 
    COREUOBJECT_API UObject* ResolveObject(UObject* Object, ERemoteReferenceType RefType = ERemoteReferenceType::Strong);
    
    COREUOBJECT_API void TouchResidentObject(UObject* Object);
 
    COREUOBJECT_API UClass* GetClass(FRemoteObjectId ObjectId, ERemoteObjectGetClassBehavior GetClassBehavior);
 
    COREUOBJECT_API bool CanResolveObject(FRemoteObjectId ObjectId);
 
    COREUOBJECT_API bool IsRemote(FRemoteObjectId ObjectId);
 
    COREUOBJECT_API bool IsRemote(const UObject* Object);
 
    COREUOBJECT_API bool IsOwned(const UObject* Object);
 
    COREUOBJECT_API bool IsOwned(FRemoteObjectId ObjectId);
 
    COREUOBJECT_API FRemoteServerId GetOwnerServerId(const UObject* Object);
 
    COREUOBJECT_API void ChangeOwnerServerId(const UObject* Object, FRemoteServerId NewOwnerServerId);
 
    COREUOBJECT_API FPhysicsIslandId GetPhysicsIslandId(const UObject* Object);
 
    COREUOBJECT_API void ChangePhysicsIslandId(const UObject* Object, FPhysicsIslandId NewPhysicsIslandId);
 
    COREUOBJECT_API void ClearAllPhysicsServerId();
 
    COREUOBJECT_API void UpdateAllPhysicsServerId(const TMap<FPhysicsIslandId, FPhysicsIslandId>& PhysicsServerMergingMap);
 
    COREUOBJECT_API void UpdateAllPhysicsLocalIslandId(const TMap<uint32, uint32>& PhysicsIslandMergingMap);
}