GlobalDirtyNetObjectTracker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Net/Core/NetBitArray.h"
#include "Net/Core/NetHandle/NetHandle.h"
#include "Containers/ContainersFwd.h"
 
class FNetCoreModule;
 
namespace UE::Net
{
 
void MarkNetObjectStateDirty(FNetHandle NetHandle, int32 StartRepIndex, int32 EndRepIndex);
 
class FGlobalDirtyNetObjectTracker
{
public:
    struct FPollHandle
    {
    public:
        FPollHandle() = default;
        FPollHandle(FPollHandle&&);
        ~FPollHandle();
 
        FPollHandle& operator=(FPollHandle&&);
 
        FPollHandle(const FPollHandle&) = delete;
        FPollHandle& operator=(const FPollHandle&) = delete;
 
        bool IsValid() const;
 
        void Destroy();
 
    private:
        friend FGlobalDirtyNetObjectTracker;
 
        enum : uint32
        {
            InvalidIndex = ~0U,
        };
 
        explicit FPollHandle(uint32 InIndex);
 
        uint32 Index = InvalidIndex;
    };
 
    using FDirtyPropertyStorage = TArray<FNetBitArrayBase::StorageWordType, TInlineAllocator<4>>;
    using FDirtyHandleAndPropertyMap = TMap<FNetHandle, FDirtyPropertyStorage>;
 
public:
    NETCORE_API static bool IsUsingPerPropertyDirtyTracking();
 
    NETCORE_API static void MarkNetObjectStateDirty(FNetHandle, const int32, const int32);
 
    inline static void MarkNetObjectStateDirty(FNetHandle Handle) 
    {
        MarkNetObjectStateDirty(Handle, INDEX_NONE, INDEX_NONE);
    }
 
    DECLARE_DELEGATE(FPreResetDelegate);
 
    NETCORE_API static FPollHandle CreatePoller(FPreResetDelegate InPreResetDelegate);
 
    NETCORE_API static const TSet<FNetHandle>& GetDirtyNetObjects(const FPollHandle& Handle);
 
    NETCORE_API static const FDirtyHandleAndPropertyMap& GetDirtyNetObjectsAndProperties(const FPollHandle& Handle);
 
    NETCORE_API static void LockDirtyListUntilReset(const FPollHandle& Handle);
 
    NETCORE_API static void ResetDirtyNetObjects(const FPollHandle&);
 
    NETCORE_API static bool ResetDirtyNetObjectsIfSinglePoller(const FPollHandle&);
 
protected:
    friend FNetCoreModule;
 
    static void Init();
 
    static void Deinit();
 
private:
    NETCORE_API static void DestroyPoller(uint32 HandleIndex);
 
    class FPimpl;
    static FPimpl* Instance;
};
 
inline void MarkNetObjectStateDirty(FNetHandle NetHandle)
{
    FGlobalDirtyNetObjectTracker::MarkNetObjectStateDirty(NetHandle, INDEX_NONE, INDEX_NONE);
}
 
inline void MarkNetObjectStateDirty(FNetHandle NetHandle, int32 StartRepIndex, int32 EndRepIndex)
{
    FGlobalDirtyNetObjectTracker::MarkNetObjectStateDirty(NetHandle, StartRepIndex, EndRepIndex);
}
 
inline FGlobalDirtyNetObjectTracker::FPollHandle::FPollHandle(uint32 InIndex)
: Index(InIndex) 
{
}
 
inline FGlobalDirtyNetObjectTracker::FPollHandle::FPollHandle(FPollHandle&& Other)
{
    Index = Other.Index;
    Other.Index = InvalidIndex;
}
 
inline FGlobalDirtyNetObjectTracker::FPollHandle& FGlobalDirtyNetObjectTracker::FPollHandle::operator=(FPollHandle&& Other)
{
    if (IsValid())
    {
        FGlobalDirtyNetObjectTracker::DestroyPoller(Index);
    }
 
    Index = Other.Index;
    Other.Index = InvalidIndex;
 
    return *this;
}
 
inline FGlobalDirtyNetObjectTracker::FPollHandle::~FPollHandle()
{
    Destroy();
}
 
inline bool FGlobalDirtyNetObjectTracker::FPollHandle::IsValid() const
{
    return Index != InvalidIndex;
}
 
inline void FGlobalDirtyNetObjectTracker::FPollHandle::Destroy()
{
    if (IsValid())
    {
        FGlobalDirtyNetObjectTracker::DestroyPoller(Index);
        Index = InvalidIndex;
    }
}
 
}