NetworkObjectList.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/NetConnection.h"
 
class AActor;
class FArchive;
 
#ifndef UE_REPLICATED_OBJECT_REFCOUNTING
    // Allows every network actor to keep track of the number of channels an individual subobject was replicated. 
    // Not needed on clients so its compiled out to reduce memory usage.
    #define UE_REPLICATED_OBJECT_REFCOUNTING WITH_SERVER_CODE
#endif
 
#ifndef DO_REPLICATED_OBJECT_CHANNELREF_CHECKS
    // Run additional code to validate any errors in the SubObject channel refcounting at the cost of extra memory usage and cpu overhead.
    #define DO_REPLICATED_OBJECT_CHANNELREF_CHECKS (UE_REPLICATED_OBJECT_REFCOUNTING && WITH_SERVER_CODE && UE_BUILD_DEVELOPMENT) 
#endif
 
enum class ENetSubObjectStatus : uint8
{
    Active,  // The subobject is active and replicated
    TearOff, // The subobject should be torn off on the clients
    Delete,  // The subobject should be deleted on the clients
};
 
struct FNetworkObjectInfo
{
    AActor* Actor;
 
    TWeakObjectPtr<AActor> WeakActor;
 
    double NextUpdateTime;
 
    double LastNetReplicateTime;
 
    float OptimalNetUpdateDelta;
 
    double LastNetUpdateTimestamp;
 
 
    struct FNetConnectionKeyFuncs : BaseKeyFuncs<TWeakObjectPtr<UNetConnection>, const TWeakObjectPtr<UNetConnection>&, false>
    {
        static KeyInitType GetSetKey(ElementInitType& Element)          { return Element; }
        static bool Matches(KeyInitType A, KeyInitType B)               { return A.HasSameIndexAndSerialNumber(B); }
        static uint32 GetKeyHash(KeyInitType Key)                       { return GetTypeHash(Key); }
    };
 
    TSet<TWeakObjectPtr<UNetConnection>, FNetConnectionKeyFuncs> DormantConnections;
 
    TSet<TWeakObjectPtr<UNetConnection>, FNetConnectionKeyFuncs> RecentlyDormantConnections;
 
    uint8 bPendingNetUpdate : 1;
 
    uint8 bDirtyForReplay : 1;
 
    uint8 bSwapRolesOnReplicate : 1;
 
    uint32 ForceRelevantFrame = 0;
 
    FNetworkObjectInfo()
        : Actor(nullptr)
        , NextUpdateTime(0.0)
        , LastNetReplicateTime(0.0)
        , OptimalNetUpdateDelta(0.0f)
        , LastNetUpdateTimestamp(0.0)
        , bPendingNetUpdate(false)
        , bDirtyForReplay(false)
        , bSwapRolesOnReplicate(false) {}
 
    FNetworkObjectInfo(AActor* InActor)
        : Actor(InActor)
        , WeakActor(InActor)
        , NextUpdateTime(0.0)
        , LastNetReplicateTime(0.0)
        , OptimalNetUpdateDelta(0.0f) 
        , LastNetUpdateTimestamp(0.0)
        , bPendingNetUpdate(false)
        , bDirtyForReplay(false)
        , bSwapRolesOnReplicate(false) {}
 
    void CountBytes(FArchive& Ar) const;
};
 
struct FNetworkObjectKeyFuncs : BaseKeyFuncs<TSharedPtr<FNetworkObjectInfo>, AActor*, false>
{
    static KeyInitType GetSetKey(ElementInitType Element)
    {
        return Element.Get()->Actor;
    }
 
    static bool Matches(KeyInitType A,KeyInitType B)
    {
        return A == B;
    }
 
    static uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};
 
class FNetworkObjectList
{
public:
    typedef TSet<TSharedPtr<FNetworkObjectInfo>, FNetworkObjectKeyFuncs> FNetworkObjectSet;
 
    ENGINE_API void AddInitialObjects(UWorld* const World, UNetDriver* NetDriver);
 
    ENGINE_API TSharedPtr<FNetworkObjectInfo>* FindOrAdd(AActor* const Actor, UNetDriver* NetDriver, bool* OutWasAdded=nullptr);
 
    ENGINE_API TSharedPtr<FNetworkObjectInfo> Find(AActor* const Actor);
    const TSharedPtr<FNetworkObjectInfo> Find(const AActor* const Actor) const
    {
        return const_cast<FNetworkObjectList*>(this)->Find(const_cast<AActor* const>(Actor));
    }
 
    ENGINE_API void Remove(AActor* const Actor);
 
    ENGINE_API void MarkDormant(AActor* const Actor, UNetConnection* const Connection, const int32 NumConnections, UNetDriver* NetDriver);
 
    ENGINE_API bool MarkActive(AActor* const Actor, UNetConnection* const Connection, UNetDriver* NetDriver);
 
    ENGINE_API void MarkDirtyForReplay(AActor* const Actor);
 
    ENGINE_API void ResetReplayDirtyTracking();
 
    ENGINE_API void ClearRecentlyDormantConnection(AActor* const Actor, UNetConnection* const Connection, UNetDriver* NetDriver);
 
    ENGINE_API void OnActorIsTraveling(AActor* TravelingAtor);
 
    ENGINE_API void OnPostSeamlessTravel();
 
    ENGINE_API void HandleConnectionAdded();
 
    ENGINE_API void ResetDormancyState();
 
    const FNetworkObjectSet& GetAllObjects() const { return AllNetworkObjects; }
 
    const FNetworkObjectSet& GetActiveObjects() const { return ActiveNetworkObjects; }
 
    const FNetworkObjectSet& GetDormantObjectsOnAllConnections() const { return ObjectsDormantOnAllConnections; }
 
    ENGINE_API int32 GetNumDormantActorsForConnection( UNetConnection* const Connection ) const;
 
    ENGINE_API void ForceActorRelevantNextUpdate(AActor* const Actor, UNetDriver* NetDriver);
        
    ENGINE_API void Reset();
 
    ENGINE_API void CountBytes(FArchive& Ar) const;
 
    ENGINE_API void FlushDormantActors(UNetConnection* const Connection, const FName& PackageName);
 
    ENGINE_API void OnActorDestroyed(AActor* DestroyedActor);
 
#if UE_REPLICATED_OBJECT_REFCOUNTING
 
    ENGINE_API void SetSubObjectForDeletion(AActor* Actor, UObject* SubObject);
 
    ENGINE_API void SetSubObjectForTearOff(AActor* Actor, UObject* SubObject);
 
    ENGINE_API void AddSubObjectChannelReference(AActor* OwnerActor, UObject* ReplicatedSubObject, UObject* ReferenceOwner);
 
    ENGINE_API void RemoveSubObjectChannelReference(AActor* OwnerActor, const TWeakObjectPtr<UObject>& ReplicatedSubObject, UObject* ReferenceOwner);
 
    ENGINE_API void RemoveMultipleSubObjectChannelReference(FObjectKey OwnerActorKey, const TArrayView<TWeakObjectPtr<UObject>>& SubObjectsToRemove, UObject* ReferenceOwner);
 
    ENGINE_API void RemoveMultipleInvalidSubObjectChannelReference(FObjectKey OwnerActorKey, const TArrayView<TWeakObjectPtr<UObject>>& SubObjectsToRemove, UObject* ReferenceOwner);
 
    ENGINE_API void RemoveMultipleActiveSubObjectChannelReference(FObjectKey OwnerActorKey, const TArrayView<TWeakObjectPtr<UObject>>& SubObjectsToRemove, UObject* ReferenceOwner);
 
    struct FActorInvalidSubObjectView;
 
    ENGINE_API FNetworkObjectList::FActorInvalidSubObjectView FindActorInvalidSubObjects(AActor* OwnerActor) const;
 
#if DO_REPLICATED_OBJECT_CHANNELREF_CHECKS
    ENGINE_API void SwapMultipleReferencesForDormancy(AActor* OwnerActor, const TArrayView<TWeakObjectPtr<UObject>>& SubObjectsToSwap, UActorChannel* PreviousChannelRefOwner, UNetConnection* NewConnectionRefOwner);
    ENGINE_API void SwapReferenceForDormancy(AActor* OwnerActor, UObject* ReplicatedSubObject, UNetConnection* PreviousConnectionRefOwner, UActorChannel* NewChannelRefOwner);
#endif 
 
#endif //#if UE_REPLICATED_OBJECT_REFCOUNTING
 
private:
    ENGINE_API bool MarkActiveInternal(const TSharedPtr<FNetworkObjectInfo>& ObjectInfo, UNetConnection* const Connection, UNetDriver* NetDriver);
 
#if UE_REPLICATED_OBJECT_REFCOUNTING
    ENGINE_API void InvalidateSubObject(AActor* Actor, UObject* SubObject, ENetSubObjectStatus InvalidStatus);
 
    struct FActorSubObjectReferences;
    ENGINE_API void HandleRemoveAnySubObjectChannelRef(FActorSubObjectReferences& SubObjectsRefInfo, const TWeakObjectPtr<UObject>& ReplicatedSubObject, UObject* ReferenceOwner);
    ENGINE_API bool HandleRemoveActiveSubObjectRef(FActorSubObjectReferences& SubObjectsRefInfo, const TWeakObjectPtr<UObject>& ReplicatedSubObject, UObject* ReferenceOwner);
    ENGINE_API bool HandleRemoveInvalidSubObjectRef(FActorSubObjectReferences& SubObjectsRefInfo, const TWeakObjectPtr<UObject>& ReplicatedSubObject, UObject* ReferenceOwner);
#endif
 
#if DO_REPLICATED_OBJECT_CHANNELREF_CHECKS
    ENGINE_API void HandleSwapReferenceForDormancy(FActorSubObjectReferences* ActorNetInfo, const TWeakObjectPtr<UObject>& SubObjectPtr, UObject* PreviousRefOwner, UObject* NewRefOwner);
#endif
 
    FNetworkObjectSet AllNetworkObjects;
    FNetworkObjectSet ActiveNetworkObjects;
    FNetworkObjectSet ObjectsDormantOnAllConnections;
 
    FNetworkObjectSet SeamlessTravelingObjects;
 
    TMap<TWeakObjectPtr<UNetConnection>, int32 > NumDormantObjectsPerConnection;
 
    TMap<FName, FNetworkObjectSet> FullyDormantObjectsByLevel;
    TMap<TObjectKey<UNetConnection>, TMap<FName, FNetworkObjectSet>> DormantObjectsPerConnection;
 
public:
 
    struct FSubObjectChannelReference
    {
        TWeakObjectPtr<UObject> SubObjectPtr;
 
        uint16 ChannelRefCount = 0;
 
        ENetSubObjectStatus Status = ENetSubObjectStatus::Active;
 
#if DO_REPLICATED_OBJECT_CHANNELREF_CHECKS
        TArray<UObject*> RegisteredOwners;
#endif
 
        inline bool operator==(const FSubObjectChannelReference& rhs) const { return SubObjectPtr.HasSameIndexAndSerialNumber(rhs.SubObjectPtr); }
        inline bool operator==(const TWeakObjectPtr<UObject>& rhs) const { return SubObjectPtr.HasSameIndexAndSerialNumber(rhs); }
 
        friend uint32 GetTypeHash(const FSubObjectChannelReference& SubObjChannelRef)
        {
            return GetTypeHash(SubObjChannelRef.SubObjectPtr);
        }
 
        inline bool IsTearOff() const { return Status == ENetSubObjectStatus::TearOff; }
        inline bool IsDelete() const { return Status == ENetSubObjectStatus::Delete; }
        inline bool IsActive() const { return Status == ENetSubObjectStatus::Active; }
 
        FSubObjectChannelReference() = default;
        explicit FSubObjectChannelReference(const TWeakObjectPtr<UObject>& InSubObject)
            : SubObjectPtr(InSubObject)
            , ChannelRefCount(1)
            , Status(ENetSubObjectStatus::Active)
        {
        }
    };
 
    struct FSubObjectChannelRefKeyFuncs : BaseKeyFuncs<FSubObjectChannelReference, const TWeakObjectPtr<UObject>&, false>
    {
        static KeyInitType  GetSetKey(ElementInitType& Element)     { return Element.SubObjectPtr; }
        static bool         Matches(KeyInitType A, KeyInitType B)   { return A.HasSameIndexAndSerialNumber(B); }
        static uint32       GetKeyHash(KeyInitType Key)             { return GetTypeHash(Key); }
    };
 
#if UE_REPLICATED_OBJECT_REFCOUNTING
 
    struct FActorInvalidSubObjectView
    {
    public:
        explicit FActorInvalidSubObjectView(uint16 InDirtyCount, const TArray<FSubObjectChannelReference>* InArrayPtr=nullptr)
            : InvalidSubObjectDirtyCount(InDirtyCount)
            , InvalidSubObjectsPtr(InArrayPtr)
        { }
 
        FActorInvalidSubObjectView() = delete;
 
        inline uint16 GetDirtyCount() const { return InvalidSubObjectDirtyCount; }
        inline bool HasInvalidSubObjects() const { return InvalidSubObjectsPtr != nullptr; }
        inline const TArray<FSubObjectChannelReference>& GetInvalidSubObjects() const 
        {
            check(HasInvalidSubObjects());
            return *InvalidSubObjectsPtr;
        }
 
    private:
        uint16 InvalidSubObjectDirtyCount = 0;
 
        const TArray<FSubObjectChannelReference>* InvalidSubObjectsPtr;
    };
 
private:
 
    struct FActorSubObjectReferences
    {
        FObjectKey ActorKey;
 
        TSet<FSubObjectChannelReference, FSubObjectChannelRefKeyFuncs> ActiveSubObjectChannelReferences;
 
        TArray<FSubObjectChannelReference> InvalidSubObjectChannelReferences;
 
        uint16 InvalidSubObjectDirtyCount = 0;
 
        explicit FActorSubObjectReferences(AActor* InActor) : ActorKey(InActor) {}
 
        bool HasNoSubObjects() const 
        {
            return ActiveSubObjectChannelReferences.IsEmpty() && InvalidSubObjectChannelReferences.IsEmpty();
        }
        
        void CountBytes(FArchive& Ar) const;
    };
 
    struct FActorSubObjectRefKeyFuncs : BaseKeyFuncs<FActorSubObjectReferences, FObjectKey, false>
    {
        static KeyInitType  GetSetKey(ElementInitType& Element)     { return Element.ActorKey; }
        static bool         Matches(KeyInitType A, KeyInitType B)   { return A == B; }
        static uint32       GetKeyHash(KeyInitType Key)             { return GetTypeHash(Key); }
    };
 
private:
 
    TSet<FActorSubObjectReferences, FActorSubObjectRefKeyFuncs> SubObjectChannelReferences;
 
#endif //UE_REPLICATED_OBJECT_REFCOUNTING
};