NetSerializer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "Iris/Serialization/NetSerializationContext.h"
#include "Iris/Serialization/NetSerializerConfig.h"
#include <limits>
 
#if 0
// Example.h
USTRUCT()
struct FExampleNetSerializerConfig : public FNetSerializerConfig
{
    GENERATED_BODY()
};
 
UE_NET_DECLARE_SERIALIZER(FFullExampleNetSerializer, EXAMPLE_API);
 
// Example.cpp
struct FExampleNetSerializer
{
    static constexpr uint32 Version = 0;
 
    // The various traits are optional and need only be specified if different from the defaults listed below.
 
    static constexpr bool bIsForwardingSerializer = false;
    static constexpr bool bHasConnectionSpecificSerialization = false;
    static constexpr bool bHasCustomNetReference = false;
    static constexpr bool bHasDynamicState = false;
    static constexpr bool bUseDefaultDelta = true;
 
    typedef FSomeSourceType SourceType;
 
    typedef FSomePodType QuantizedType;
 
    typedef FNetSerializerConfig ConfigType;
 
    inline static const ConfigType DefaultConfig;
 
 
    static void Serialize(FNetSerializationContext&, const FNetSerializeArgs&);
    static void Deserialize(FNetSerializationContext&, const FNetDeserializeArgs&);
 
    static void SerializeDelta(FNetSerializationContext&, const FNetSerializeDeltaArgs&);
 
    static void DeserializeDelta(FNetSerializationContext&, const FNetDeserializeDeltaArgs&);
 
    static void Quantize(FNetSerializationContext&, const FNetQuantizeArgs&);
 
    static void Dequantize(FNetSerializationContext&, const FNetDequantizeArgs&);
 
    static bool IsEqual(FNetSerializationContext&, const FNetIsEqualArgs&);
 
    static bool Validate(FNetSerializationContext&, const FNetValidateArgs&);
 
    static void CloneDynamicState(FNetSerializationContext&, const FNetCloneDynamicStateArgs&);
 
    static void FreeDynamicState(FNetSerializationContext&, const FNetFreeDynamicStateArgs&);
 
    static void CollectNetReferences(FNetSerializationContext&, const FNetCollectReferencesArgs&);
 
    static void Apply(FNetSerializationContext&, const FNetApplyArgs&);
};
UE_NET_IMPLEMENT_SERIALIZER(FExampleNetSerializer);
 
#endif
 
namespace UE::Net
{
    class FNetBitArrayView;
    class FNetMemoryContext;
}
 
namespace UE::Net
{
 
typedef UPTRINT NetSerializerValuePointer;
typedef const FNetSerializerConfig* NetSerializerConfigParam;
 
struct FNetSerializerChangeMaskParam
{
    uint32 BitOffset = 0;
    uint32 BitCount = 0;
};
 
struct FNetSerializerBaseArgs
{
    NetSerializerConfigParam NetSerializerConfig = 0;
    FNetSerializerChangeMaskParam ChangeMaskInfo;
    uint32 Version = 0;
};
 
struct FNetCollectReferencesArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
    NetSerializerValuePointer Collector;
};
typedef void(*NetCollectNetReferencesFunction)(FNetSerializationContext&, const FNetCollectReferencesArgs&);
 
struct FNetSerializeArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
};
typedef void(*NetSerializeFunction)(FNetSerializationContext&, const FNetSerializeArgs&);
 
struct FNetDeserializeArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Target;
};
typedef void(*NetDeserializeFunction)(FNetSerializationContext&, const FNetDeserializeArgs&);
 
struct FNetSerializeDeltaArgs : FNetSerializeArgs
{
    NetSerializerValuePointer Prev;
};
typedef void(*NetSerializeDeltaFunction)(FNetSerializationContext&, const FNetSerializeDeltaArgs&);
 
struct FNetDeserializeDeltaArgs : FNetDeserializeArgs
{
    NetSerializerValuePointer Prev;
};
typedef void(*NetDeserializeDeltaFunction)(FNetSerializationContext&, const FNetDeserializeDeltaArgs&);
 
struct FNetQuantizeArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
    NetSerializerValuePointer Target;
};
typedef void(*NetQuantizeFunction)(FNetSerializationContext&, const FNetQuantizeArgs&);
 
struct FNetDequantizeArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
    NetSerializerValuePointer Target;
};
typedef void(*NetDequantizeFunction)(FNetSerializationContext&, const FNetDequantizeArgs&);
 
struct FNetIsEqualArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source0;
    NetSerializerValuePointer Source1;
    bool bStateIsQuantized;
};
typedef bool(*NetIsEqualFunction)(FNetSerializationContext&, const FNetIsEqualArgs&);
 
struct FNetValidateArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
};
typedef bool(*NetValidateFunction)(FNetSerializationContext&, const FNetValidateArgs&);
 
struct FNetCloneDynamicStateArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
    NetSerializerValuePointer Target;
};
typedef void(*NetCloneDynamicStateFunction)(FNetSerializationContext&, const FNetCloneDynamicStateArgs&);
 
struct FNetFreeDynamicStateArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
};
typedef void(*NetFreeDynamicStateFunction)(FNetSerializationContext&, const FNetFreeDynamicStateArgs&);
 
struct FNetApplyArgs : FNetSerializerBaseArgs
{
    NetSerializerValuePointer Source;
    NetSerializerValuePointer Target;
};
typedef void(*NetApplyFunction)(FNetSerializationContext&, const FNetApplyArgs&);
 
enum class ENetSerializerTraits : uint32
{
    None = 0U,
    IsForwardingSerializer = 1U << 0U,
    HasDynamicState = IsForwardingSerializer << 1U,
    HasConnectionSpecificSerialization = HasDynamicState << 1U,
    HasCustomNetReference = HasConnectionSpecificSerialization << 1U,
 
    UseSerializerIsEqual = HasCustomNetReference << 1U,
 
    HasApply = UseSerializerIsEqual << 1U,
};
ENUM_CLASS_FLAGS(ENetSerializerTraits);
 
struct FNetSerializer
{
    uint32 Version;
    ENetSerializerTraits Traits;
 
    NetSerializeFunction Serialize;
    NetDeserializeFunction Deserialize;
    NetSerializeDeltaFunction SerializeDelta;
    NetDeserializeDeltaFunction DeserializeDelta;
    NetQuantizeFunction Quantize;
    NetDequantizeFunction Dequantize;
    NetIsEqualFunction IsEqual;
    NetValidateFunction Validate;
    NetCloneDynamicStateFunction CloneDynamicState;
    NetFreeDynamicStateFunction FreeDynamicState;
    NetCollectNetReferencesFunction CollectNetReferences;
    NetApplyFunction Apply;
    const FNetSerializerConfig* DefaultConfig;
    uint16 QuantizedTypeSize;
    uint16 QuantizedTypeAlignment;
    uint16 ConfigTypeSize;
    uint16 ConfigTypeAlignment;
 
    const TCHAR* Name;
};
 
}
 
#include "NetSerializerBuilder.inl"
 
namespace UE::Net
{
 
template<typename NetSerializerImpl>
class TNetSerializer
{
public:
    static constexpr FNetSerializer ConstructNetSerializer(const TCHAR* Name)
    {
        TNetSerializerBuilder<NetSerializerImpl> Builder;
        Builder.Validate();
 
        FNetSerializer Serializer = {};
        Serializer.Version = Builder.GetVersion();
        Serializer.Traits = Builder.GetTraits();
 
        Serializer.Serialize = Builder.GetSerializeFunction();
        Serializer.Deserialize = Builder.GetDeserializeFunction();
        Serializer.SerializeDelta = Builder.GetSerializeDeltaFunction();
        Serializer.DeserializeDelta = Builder.GetDeserializeDeltaFunction();
        Serializer.Quantize = Builder.GetQuantizeFunction();
        Serializer.Dequantize = Builder.GetDequantizeFunction();
        Serializer.IsEqual = Builder.GetIsEqualFunction();
        Serializer.Validate = Builder.GetValidateFunction();
        Serializer.CloneDynamicState = Builder.GetCloneDynamicStateFunction();
        Serializer.FreeDynamicState = Builder.GetFreeDynamicStateFunction();
        Serializer.CollectNetReferences = Builder.GetCollectNetReferencesFunction();
        Serializer.Apply = Builder.GetApplyFunction();
 
        Serializer.DefaultConfig = Builder.GetDefaultConfig();
 
        static_assert(Builder.GetQuantizedTypeSize() <= std::numeric_limits<uint16>::max(), "");
        Serializer.QuantizedTypeSize = static_cast<uint16>(Builder.GetQuantizedTypeSize());
        static_assert(Builder.GetQuantizedTypeAlignment() <= std::numeric_limits<uint16>::max(), "");
        Serializer.QuantizedTypeAlignment = static_cast<uint16>(Builder.GetQuantizedTypeAlignment());
 
        static_assert(Builder.GetConfigTypeSize() <= std::numeric_limits<uint16>::max(), "");
        Serializer.ConfigTypeSize = static_cast<uint16>(Builder.GetConfigTypeSize());
        static_assert(Builder.GetConfigTypeAlignment() <= std::numeric_limits<uint16>::max(), "");
        Serializer.ConfigTypeAlignment = static_cast<uint16>(Builder.GetConfigTypeAlignment());
 
        Serializer.Name = Name;
        return Serializer;
    }
};
 
}
 
#define UE_NET_DECLARE_SERIALIZER(SerializerName, Api) struct Api SerializerName ## NetSerializerInfo  \
{ \
    static const UE::Net::FNetSerializer Serializer; \
    static uint32 GetQuantizedTypeSize(); \
    static uint32 GetQuantizedTypeAlignment(); \
    static const FNetSerializerConfig* GetDefaultConfig(); \
};
 
#define UE_NET_IMPLEMENT_SERIALIZER(SerializerName) const UE::Net::FNetSerializer SerializerName ## NetSerializerInfo::Serializer = UE::Net::TNetSerializer<SerializerName>::ConstructNetSerializer(TEXT(#SerializerName)); \
    uint32 SerializerName ## NetSerializerInfo::GetQuantizedTypeSize() { return UE::Net::TNetSerializerBuilder<SerializerName>::GetQuantizedTypeSize(); }; \
    uint32 SerializerName ## NetSerializerInfo::GetQuantizedTypeAlignment() { return UE::Net::TNetSerializerBuilder<SerializerName>::GetQuantizedTypeAlignment(); }; \
    const FNetSerializerConfig* SerializerName ## NetSerializerInfo::GetDefaultConfig() { return UE::Net::TNetSerializerBuilder<SerializerName>::GetDefaultConfig(); };
 
#define UE_NET_GET_SERIALIZER(SerializerName) static_cast<const UE::Net::FNetSerializer&>(SerializerName ## NetSerializerInfo::Serializer)
#define UE_NET_GET_SERIALIZER_INTERNAL_TYPE_SIZE(SerializerName) SerializerName ## NetSerializerInfo::GetQuantizedTypeSize()
#define UE_NET_GET_SERIALIZER_INTERNAL_TYPE_ALIGNMENT(SerializerName) SerializerName ## NetSerializerInfo::GetQuantizedTypeAlignment()
#define UE_NET_GET_SERIALIZER_DEFAULT_CONFIG(SerializerName) SerializerName ## NetSerializerInfo::GetDefaultConfig()