DirtyNetObjectTracker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Logging/LogMacros.h"
 
#include "Net/Core/NetBitArray.h"
#include "Net/Core/DirtyNetObjectTracker/GlobalDirtyNetObjectTracker.h"
 
#include "Iris/IrisConfig.h"
#include "Iris/Core/IrisCsv.h"
 
namespace UE::Net::Private
{
    class FNetRefHandleManager;
    class FDirtyObjectsAccessor;
    
    typedef uint32 FInternalNetRefIndex;
}
 
#ifndef UE_NET_DIRTYOBJECTTRACKER_LOG_COMPILE_VERBOSITY
// Don't compile verbose logs in Shipping builds    
#if UE_BUILD_SHIPPING
#   define UE_NET_DIRTYOBJECTTRACKER_LOG_COMPILE_VERBOSITY Log
#else
#   define UE_NET_DIRTYOBJECTTRACKER_LOG_COMPILE_VERBOSITY All
#endif
#endif
 
IRISCORE_API DECLARE_LOG_CATEGORY_EXTERN(LogIrisDirtyTracker, Log, UE_NET_DIRTYOBJECTTRACKER_LOG_COMPILE_VERBOSITY);
 
namespace UE::Net::Private
{
 
IRISCORE_API void MarkNetObjectStateDirty(uint32 ReplicationSystemId, FInternalNetRefIndex NetObjectIndex);
IRISCORE_API void ForceNetUpdate(uint32 ReplicationSystemId, FInternalNetRefIndex NetObjectIndex);
 
struct FDirtyNetObjectTrackerInitParams
{
    const FNetRefHandleManager* NetRefHandleManager = nullptr;
    uint32 ReplicationSystemId = 0;
    uint32 MaxInternalNetRefIndex = 0;
};
 
class FDirtyNetObjectTracker
{
public:
    FDirtyNetObjectTracker();
    ~FDirtyNetObjectTracker();
 
    void Init(const FDirtyNetObjectTrackerInitParams& Params);
    void Deinit();
 
    bool IsInit() const { return NetRefHandleManager != nullptr; }
 
    void UpdateDirtyNetObjects();
 
    /* Update dirty objects from the global list and then prevent future modifications to that list until it is reset. */
    void UpdateAndLockDirtyNetObjects();
 
    void UpdateAccumulatedDirtyList();
 
    void LockExternalAccess();
 
    void AllowExternalAccess();
 
    void ReconcilePolledList(const FNetBitArrayView& ObjectsPolled);
 
#if UE_NET_IRIS_CSV_STATS
    void ReportCSVStats();
#endif
 
    const FNetBitArrayView GetAccumulatedDirtyNetObjects() const { return MakeNetBitArrayView(AccumulatedDirtyNetObjects); }
 
    FNetBitArrayView GetForceNetUpdateObjects() { return MakeNetBitArrayView(ForceNetUpdateObjects); }
    const FNetBitArrayView GetForceNetUpdateObjects() const { return MakeNetBitArrayView(ForceNetUpdateObjects); }
 
private:
    friend IRISCORE_API void MarkNetObjectStateDirty(uint32 ReplicationSystemId, FInternalNetRefIndex NetObjectIndex);
    friend IRISCORE_API void ForceNetUpdate(uint32 ReplicationSystemId, FInternalNetRefIndex NetObjectIndex);
 
    friend FDirtyObjectsAccessor;
 
    using StorageType = FNetBitArrayView::StorageWordType;
    static constexpr uint32 StorageTypeBitCount = FNetBitArrayView::WordBitCount;
 
    void SetNetObjectListsSize(FInternalNetRefIndex NewMaxInternalIndex);
    void OnMaxInternalNetRefIndexIncreased(FInternalNetRefIndex NewMaxInternalIndex);
 
    void MarkNetObjectDirty(FInternalNetRefIndex NetObjectIndex);
    void ForceNetUpdate(FInternalNetRefIndex NetObjectIndex);
    void ApplyGlobalDirtyObjectList();
 
    void ApplyAndTryResetGlobalDirtyObjectList();
 
    FNetBitArrayView GetDirtyNetObjectsThisFrame();
 
    bool MarkPushbasedPropertiesDirty(FInternalNetRefIndex ObjectIndex, uint16 OwnerIndex, const FNetBitArrayView& DirtyProperties);
 
private:
 
    // Dirty objects that persist across frames.
    FNetBitArray AccumulatedDirtyNetObjects;
 
    // Objects that want to force a replication this frame
    FNetBitArray ForceNetUpdateObjects;
 
    // List of objects set to be dirty this frame. Is always reset at the end of the net tick flush
    FNetBitArray DirtyNetObjects;
 
    const FNetRefHandleManager* NetRefHandleManager = nullptr;
    
    FGlobalDirtyNetObjectTracker::FPollHandle GlobalDirtyTrackerPollHandle;
 
    uint32 ReplicationSystemId;
 
    uint32 NetObjectIdCount = 0;
    
    bool bShouldResetPolledGlobalDirtyTracker = false;
 
#if UE_NET_THREAD_SAFETY_CHECK
    bool bIsExternalAccessAllowed = false;
#endif
 
#if UE_NET_IRIS_CSV_STATS
    int32 PushModelDirtyObjectsCount = 0;
    int32 ForceNetUpdateObjectsCount = 0;
#endif
};
 
class FDirtyObjectsAccessor
{
public:
    FDirtyObjectsAccessor(FDirtyNetObjectTracker& InDirtyNetObjectTracker)
        : DirtyNetObjectTracker(InDirtyNetObjectTracker)
    {
        DirtyNetObjectTracker.LockExternalAccess();
    }
 
    ~FDirtyObjectsAccessor()
    {
        DirtyNetObjectTracker.AllowExternalAccess();
    }
 
    FNetBitArrayView GetDirtyNetObjects()               { return DirtyNetObjectTracker.GetDirtyNetObjectsThisFrame(); }
    const FNetBitArrayView GetDirtyNetObjects() const   { return DirtyNetObjectTracker.GetDirtyNetObjectsThisFrame(); }
 
private:
    FDirtyNetObjectTracker& DirtyNetObjectTracker;
};
 
}