PushModelPerObjectState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Net/Core/PushModel/PushModelMacros.h"
 
#if WITH_PUSH_MODEL
 
#include "CoreMinimal.h"
#include "PushModelPerNetDriverState.h"
#include "PushModelUtils.h"
#include "Net/Core/PushModel/PushModel.h"
#include "Containers/SparseArray.h"
#include "UObject/ObjectKey.h"
 
namespace UEPushModelPrivate
{
    class FPushModelPerObjectState
    {
    public:
 
        FPushModelPerObjectState(const FObjectKey InObjectKey, const uint16 InNumberOfProperties)
            : ObjectKey(InObjectKey)
            , DirtiedThisFrame(true, InNumberOfProperties)
            , bHasDirtyProperties(true)
        {
        }
 
        FPushModelPerObjectState(FPushModelPerObjectState&& Other)
            : ObjectKey(Other.ObjectKey)
            , DirtiedThisFrame(MoveTemp(Other.DirtiedThisFrame))
            , PerNetDriverStates(MoveTemp(Other.PerNetDriverStates))
            , bHasDirtyProperties(Other.bHasDirtyProperties)
        {
            Other.bHasDirtyProperties = false;
        }
 
        FPushModelPerObjectState(const FPushModelPerObjectState& Other) = delete;
        FPushModelPerObjectState& operator=(const FPushModelPerObjectState& Other) = delete;
 
        void SetRecentlyCollectedGarbage()
        {
            for (FPushModelPerNetDriverState& NetDriverObject : PerNetDriverStates)
            {
                NetDriverObject.SetRecentlyCollectedGarbage();
            }
        }
 
        void MarkPropertyDirty(const uint16 RepIndex)
        {
            DirtiedThisFrame[RepIndex] = true;
            bHasDirtyProperties = true;
        }
        
        void PushDirtyStateToNetDrivers()
        {
            if (bHasDirtyProperties)
            {
                for (FPushModelPerNetDriverState& NetDriverObject : PerNetDriverStates)
                {
                    NetDriverObject.MarkPropertiesDirty(DirtiedThisFrame);
                }
 
                ResetBitArray(DirtiedThisFrame);
                bHasDirtyProperties = false;
            }
        }
 
        FPushModelPerNetDriverState& GetPerNetDriverState(FNetPushPerNetDriverId DriverId)
        {
            return PerNetDriverStates[DriverId];
        }
 
        const FPushModelPerNetDriverState& GetPerNetDriverState(FNetPushPerNetDriverId DriverId) const
        {
            return PerNetDriverStates[DriverId];
        }
        
        FNetPushPerNetDriverId AddPerNetDriverState()
        {
            FSparseArrayAllocationInfo AllocationInfo = PerNetDriverStates.AddUninitialized();
            new (AllocationInfo.Pointer) FPushModelPerNetDriverState(static_cast<uint16>(DirtiedThisFrame.Num()));
            
            return AllocationInfo.Index;
        }
        
        void RemovePerNetDriverState(const FNetPushPerNetDriverId DriverId)
        {
            PerNetDriverStates.RemoveAt(DriverId);
        }
        
        const bool HasAnyNetDriverStates()
        {
            return PerNetDriverStates.Num() != 0;
        }
        
        void CountBytes(FArchive& Ar) const
        {
            DirtiedThisFrame.CountBytes(Ar);
            PerNetDriverStates.CountBytes(Ar);
            for (const FPushModelPerNetDriverState& PerNetDriverState : PerNetDriverStates)
            {
                PerNetDriverState.CountBytes(Ar);
            }
        }
        
        const int32 GetNumberOfProperties() const
        {
            return DirtiedThisFrame.Num();
        }
 
        const FObjectKey& GetObjectKey() const
        {
            return ObjectKey;
        }
 
        bool HasDirtyProperties() const
        {
            return bHasDirtyProperties;
        }
 
    private:
    
        const FObjectKey ObjectKey;
 
        TBitArray<> DirtiedThisFrame;
 
        TSparseArray<FPushModelPerNetDriverState> PerNetDriverStates;
 
        uint8 bHasDirtyProperties : 1;
    };
}
 
#endif