NetObjectFilter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Net/Core/NetBitArray.h"
#include "Iris/Core/NetChunkedArray.h"
#include "Iris/ReplicationSystem/ReplicationView.h"
#include "UObject/ObjectMacros.h"
#include "NetObjectFilter.generated.h"
 
struct FNetObjectFilteringInfo;
class UReplicationSystem;
namespace UE::Net
{
    typedef uint32 FNetObjectFilterHandle;
    struct FReplicationInstanceProtocol;
    struct FReplicationProtocol;
    class FNetRefHandle;
 
    namespace Private
    {
        typedef uint32 FInternalNetRefIndex;
        class FNetRefHandleManager;
    }
}
 
namespace UE::Net
{
 
constexpr FNetObjectFilterHandle InvalidNetObjectFilterHandle = FNetObjectFilterHandle(0);
constexpr FNetObjectFilterHandle ToOwnerFilterHandle = FNetObjectFilterHandle(1);
constexpr FNetObjectFilterHandle ConnectionFilterHandle = FNetObjectFilterHandle(2);
 
enum class ENetFilterStatus : uint32
{
    Disallow,
    Allow,
};
 
IRISCORE_API const TCHAR* LexToString(ENetFilterStatus Status);
 
} // end namespace UE::Net
 
struct FNetObjectFilteringParams
{
    UE::Net::FNetBitArrayView OutAllowedObjects;
 
    TArrayView<const FNetObjectFilteringInfo> FilteringInfos;
 
    const UE::Net::TNetChunkedArray<uint8*>* StateBuffers = nullptr;
 
    uint32 ConnectionId = 0;
 
    UE::Net::FReplicationView View;
 
    const UE::Net::FNetBitArrayView GroupFilteredOutObjects;
};
 
struct FNetObjectPreFilteringParams
{
    // The IDs of all valid connections.
    UE::Net::FNetBitArrayView ValidConnections;
 
    TArrayView<const FNetObjectFilteringInfo> FilteringInfos;
};
 
struct FNetObjectPostFilteringParams
{
};
 
struct alignas(8) FNetObjectFilteringInfo
{
    uint16 Data[4];
};
 
enum class ENetFilterTraits : uint8
{
    None = 0x00,
    Spatial = 0x01,
    NeedsUpdate = 0x02,
};
ENUM_CLASS_FLAGS(ENetFilterTraits);
 
UCLASS(Transient, MinimalAPI, config=Engine)
class UNetObjectFilterConfig : public UObject
{
    GENERATED_BODY()
 
public:
};
 
struct FNetObjectFilterInitParams
{
public:
    TObjectPtr<UReplicationSystem> ReplicationSystem = nullptr;
    UNetObjectFilterConfig* Config = nullptr;
    uint32 AbsoluteMaxNetObjectCount = 0;
    uint32 CurrentMaxInternalIndex = 0;
    uint32 MaxConnectionCount = 0;
};
 
struct FNetObjectFilterAddObjectParams
{
    FNetObjectFilteringInfo& OutInfo;
 
    FName ProfileName;
 
    const UE::Net::FReplicationInstanceProtocol* InstanceProtocol;
 
    const UE::Net::FReplicationProtocol* Protocol;
 
    const uint8* StateBuffer;
};
 
struct FNetObjectFilterUpdateParams
{
    const uint32* ObjectIndices = nullptr;
    uint32 ObjectCount = 0;
 
    TArrayView<FNetObjectFilteringInfo> FilteringInfos;
};
 
UCLASS(Abstract, MinimalAPI)
class UNetObjectFilter : public UObject
{
    GENERATED_BODY()
 
public:
    IRISCORE_API void Init(const FNetObjectFilterInitParams& Params);
    IRISCORE_API void Deinit();
 
    IRISCORE_API void MaxInternalNetRefIndexIncreased(UE::Net::Private::FInternalNetRefIndex MaxInternalIndex, TArrayView<FNetObjectFilteringInfo> NewFilterInfoView);
    
    IRISCORE_API virtual void AddConnection(uint32 ConnectionId);
 
    IRISCORE_API virtual void RemoveConnection(uint32 ConnectionId);
 
    virtual bool AddObject(uint32 ObjectIndex, FNetObjectFilterAddObjectParams&) PURE_VIRTUAL(AddObject, return false;)
 
    virtual void RemoveObject(uint32 ObjectIndex, const FNetObjectFilteringInfo&) PURE_VIRTUAL(RemoveObject,)
 
    
    IRISCORE_API virtual void UpdateObjects(FNetObjectFilterUpdateParams&);
 
    IRISCORE_API virtual void PreFilter(FNetObjectPreFilteringParams&);
 
    IRISCORE_API virtual void Filter(FNetObjectFilteringParams&);
 
    IRISCORE_API virtual void PostFilter(FNetObjectPostFilteringParams&);
 
    ENetFilterTraits GetFilterTraits() const { return FilterTraits; }
 
    bool HasFilterTrait(ENetFilterTraits FilterTrait) const { return EnumHasAnyFlags(FilterTraits, FilterTrait); }
 
    UE::Net::FNetBitArrayView GetFilteredObjects() { return MakeNetBitArrayView(FilteredObjects); }
 
 
    struct FDebugInfoParams
    {
        FName FilterName;
 
        TArrayView<const FNetObjectFilteringInfo> FilteringInfos;
 
        uint32 ConnectionId = 0;
 
        UE::Net::FReplicationView View;
    };
    virtual FString PrintDebugInfoForObject(const FDebugInfoParams& Params, uint32 ObjectIndex) const { return Params.FilterName.ToString(); };
 
protected:
    IRISCORE_API UNetObjectFilter();
 
    virtual void OnInit(const FNetObjectFilterInitParams&) PURE_VIRTUAL(OnInit, );
 
    virtual void OnDeinit() PURE_VIRTUAL(OnDeinit);
 
    virtual void OnMaxInternalNetRefIndexIncreased(uint32 NewMaxInternalIndex) PURE_VIRTUAL(OnMaxInternalNetRefIndexIncreased);
 
    /* Returns the filtering info for this object if it's handled by this filter, nullptr otherwise. */
    IRISCORE_API FNetObjectFilteringInfo* GetFilteringInfo(uint32 ObjectIndex);
 
    /* Returns the object index for the given NetRefHandle */
    IRISCORE_API uint32 GetObjectIndex(UE::Net::FNetRefHandle NetRefHandle) const;
 
    /* Returns true if the object is assigned to be filtered by this filter.*/
    inline bool IsObjectFiltered(uint32 ObjectIndex) const;
 
    inline void AddFilterTraits(ENetFilterTraits Traits);
 
    inline void SetFilterTraits(ENetFilterTraits Traits, ENetFilterTraits TraitsMask);
 
protected:
 
    UE::Net::FNetBitArray FilteredObjects;
 
    const UE::Net::Private::FNetRefHandleManager* NetRefHandleManager = nullptr;
 
private:
    ENetFilterTraits FilterTraits = ENetFilterTraits::None;
    
    TArrayView<FNetObjectFilteringInfo> FilteringInfos; 
};
 
inline bool UNetObjectFilter::IsObjectFiltered(uint32 ObjectIndex) const
{
    return ObjectIndex < FilteredObjects.GetNumBits() && FilteredObjects.IsBitSet(ObjectIndex);
}
 
inline void UNetObjectFilter::AddFilterTraits(ENetFilterTraits Traits)
{
    FilterTraits |= Traits;
}
 
inline void UNetObjectFilter::SetFilterTraits(ENetFilterTraits Traits, ENetFilterTraits TraitsMask)
{
    const ENetFilterTraits NewFilterTraits = (FilterTraits & ~TraitsMask) | (Traits & TraitsMask);
    FilterTraits = NewFilterTraits;
}