NetBlob.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "CoreTypes.h"
#include "Iris/Core/NetObjectReference.h"
#include "Iris/ReplicationState/ReplicationStateDescriptor.h"
#include "HAL/UnrealMemory.h"
#include "Containers/ArrayView.h"
#include "Templates/RefCounting.h"
#include "Templates/UniquePtr.h"
 
namespace UE::Net
{
    class FNetBlob;
    class FNetSerializationContext;
    struct FReplicationStateDescriptor;
    class FNetReferenceCollector;
    namespace Private
    {
        class FNetBlobManager;
    }
}
 
namespace UE::Net
{
 
enum class ENetBlobFlags : uint32
{
    None = 0,
 
    Reliable = 1U << 0U,
 
    RawDataNetBlob = Reliable << 1U,
 
    HasExports = RawDataNetBlob << 1U,
 
    Ordered = HasExports << 1U,
};
ENUM_CLASS_FLAGS(ENetBlobFlags);
 
typedef uint32 FNetBlobType;
 
constexpr FNetBlobType InvalidNetBlobType = ~FNetBlobType(0);
 
struct FNetBlobCreationInfo
{
    FNetBlobType Type = InvalidNetBlobType;
    ENetBlobFlags Flags = ENetBlobFlags::None;
};
 
class FNetBlob
{
public:
    struct FQuantizedBlobState
    {
        enum class EMemoryAllocationFlags : uint32
        {
            None = 0,
            // If the state is constructed as protectable one can call Protect() to detect memory stomps.
            Protectable = 1,
        };
 
        FQuantizedBlobState() = default;
        FQuantizedBlobState(const FQuantizedBlobState&) = delete;
        FQuantizedBlobState(FQuantizedBlobState&&);
        IRISCORE_API FQuantizedBlobState(uint32 Size, uint32 Alignment, EMemoryAllocationFlags MemoryAllocationFlags = EMemoryAllocationFlags::None);
        IRISCORE_API ~FQuantizedBlobState();
 
        FQuantizedBlobState& operator=(const FQuantizedBlobState&) = delete;
        FQuantizedBlobState& operator=(FQuantizedBlobState&&);
 
        uint8* GetStateBuffer() { return StateBuffer; }
        const uint8* GetStateBuffer() const { return StateBuffer; }
 
        IRISCORE_API void Protect();
 
        IRISCORE_API void Unprotect();
 
    private:
        uint8* StateBuffer = nullptr;
        EMemoryAllocationFlags MemoryAllocationFlags = EMemoryAllocationFlags::None;
        uint32 AllocationSize = 0;
    };
 
    IRISCORE_API FNetBlob(const FNetBlobCreationInfo&);
 
    IRISCORE_API void SetState(const TRefCountPtr<const FReplicationStateDescriptor>& BlobDescriptor, FQuantizedBlobState&& QuantizedBlobState);
 
    const FNetBlobCreationInfo& GetCreationInfo() const { return CreationInfo; }
 
    /* Whether the blob is reliably sent or not. */
    bool IsReliable() const { return EnumHasAnyFlags(GetCreationInfo().Flags, ENetBlobFlags::Reliable); }
 
    const FReplicationStateDescriptor* GetReplicationStateDescriptor() const { return BlobDescriptor.GetReference(); }
 
    IRISCORE_API static void SerializeCreationInfo(FNetSerializationContext& Context, const FNetBlobCreationInfo& CreationInfo);
 
    IRISCORE_API static void DeserializeCreationInfo(FNetSerializationContext& Context, FNetBlobCreationInfo& OutCreationInfo);
 
    IRISCORE_API virtual void SerializeWithObject(FNetSerializationContext& Context, FNetRefHandle RefHandle) const;
 
    IRISCORE_API virtual void DeserializeWithObject(FNetSerializationContext& Context, FNetRefHandle RefHandle);
 
    IRISCORE_API virtual void Serialize(FNetSerializationContext& Context) const;
 
    IRISCORE_API virtual void Deserialize(FNetSerializationContext& Context);
 
    IRISCORE_API void CollectObjectReferences(FNetSerializationContext& Context, FNetReferenceCollector& Collector) const;
 
    void AddRef() const { ++RefCount; }
 
    IRISCORE_API void Release() const;
 
    int32 GetRefCount() const { return RefCount; }
 
    /* Returns true if the blob has additional exports to add. */
    bool HasExports() const { return EnumHasAnyFlags(GetCreationInfo().Flags, ENetBlobFlags::HasExports); }
 
    TArrayView<const FNetObjectReference> CallGetNetObjectReferenceExports() const { return GetNetObjectReferenceExports(); };
 
    TArrayView<const FNetToken> CallGetNetTokenExports() const { return GetNetTokenExports(); };
 
protected:
    FNetBlob(const FNetBlob&) = delete;
    FNetBlob& operator=(const FNetBlob&) = delete;
 
    IRISCORE_API virtual ~FNetBlob();
 
    virtual TArrayView<const FNetObjectReference> GetNetObjectReferenceExports() const;
 
    virtual TArrayView<const FNetToken> GetNetTokenExports() const;
 
    IRISCORE_API void SerializeBlob(FNetSerializationContext& Context) const;
 
    IRISCORE_API void DeserializeBlob(FNetSerializationContext& Context);
 
protected:
    FNetBlobCreationInfo CreationInfo;
 
    TRefCountPtr<const FReplicationStateDescriptor> BlobDescriptor;
 
    FQuantizedBlobState QuantizedBlobState;
 
private:
    mutable int32 RefCount;
};
 
class FNetObjectAttachment : public FNetBlob
{
public:
    IRISCORE_API FNetObjectAttachment(const FNetBlobCreationInfo&);
    const FNetObjectReference& GetNetObjectReference() const { return NetObjectReference; }
    const FNetObjectReference& GetTargetObjectReference() const { return TargetObjectReference; }
 
protected:
    virtual ~FNetObjectAttachment();
 
    IRISCORE_API void SerializeObjectReference(FNetSerializationContext& Context) const;
 
    IRISCORE_API void DeserializeObjectReference(FNetSerializationContext& Context);
 
    IRISCORE_API void SerializeSubObjectReference(FNetSerializationContext& Context, FNetRefHandle RefHandle) const;
 
    IRISCORE_API void DeserializeSubObjectReference(FNetSerializationContext& Context, FNetRefHandle RefHandle);
 
    void SetNetObjectReference(const FNetObjectReference& InQueueOwnerReference, const FNetObjectReference& InTargetObjectReference);
 
protected:
    friend class Private::FNetBlobManager;
 
    FNetObjectReference NetObjectReference;
 
    FNetObjectReference TargetObjectReference;
};
 
inline FNetBlob::FQuantizedBlobState::FQuantizedBlobState(FNetBlob::FQuantizedBlobState&& Other)
{
    StateBuffer = Other.StateBuffer;
    MemoryAllocationFlags = Other.MemoryAllocationFlags;
    AllocationSize = Other.AllocationSize;
 
    Other.StateBuffer = nullptr;
    Other.MemoryAllocationFlags = EMemoryAllocationFlags::None;
    Other.AllocationSize = 0;
}
 
inline FNetBlob::FQuantizedBlobState& FNetBlob::FQuantizedBlobState::operator=(FNetBlob::FQuantizedBlobState&& Other)
{
    if (StateBuffer)
    {
        Unprotect();
        FMemory::Free(StateBuffer);
    }
 
    StateBuffer = Other.StateBuffer;
    MemoryAllocationFlags = Other.MemoryAllocationFlags;
    AllocationSize = Other.AllocationSize;
 
    Other.StateBuffer = nullptr;
    Other.MemoryAllocationFlags = EMemoryAllocationFlags::None;
    Other.AllocationSize = 0;
    return *this;
}
 
inline void FNetObjectAttachment::SetNetObjectReference(const FNetObjectReference& InQueueOwnerReference, const FNetObjectReference& InTargetObjectReference)
{
    NetObjectReference = InQueueOwnerReference;
    if (InQueueOwnerReference != InTargetObjectReference)
    {
        TargetObjectReference = InTargetObjectReference;
    }
}
 
}