NetBitStreamUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/StringView.h"
#include "Misc/AssertionMacros.h"
#include "Iris/Serialization/NetBitStreamWriter.h"
#include "Iris/Serialization/NetBitStreamReader.h"
#include "Iris/IrisConfig.h"
 
namespace UE::Net
{
 
class FNetBitStreamWriteScope
{
public:
    FNetBitStreamWriteScope(FNetBitStreamWriter& InWriter, uint32 WritePos)
    : Writer(InWriter)
    , OriginalPos(InWriter.GetPosBits())
    {
#if UE_NETBITSTREAMWRITER_VALIDATE
        check(!Writer.IsOverflown());
#endif
 
        Writer.Seek(WritePos);
    }
 
    ~FNetBitStreamWriteScope()
    {
#if UE_NETBITSTREAMWRITER_VALIDATE
        check(Writer.GetPosBits() <= OriginalPos);
#endif
        Writer.Seek(OriginalPos);
    }
 
private:
    FNetBitStreamWriter& Writer;
    const uint32 OriginalPos;
};
 
 
class FNetBitStreamRollbackScope
{
public:
    explicit FNetBitStreamRollbackScope(FNetBitStreamWriter& InWriter)
    : Writer(InWriter)
    , StartPos(InWriter.GetPosBits())
    {
    }
 
    ~FNetBitStreamRollbackScope()
    {
        if (Writer.IsOverflown())
        {
            Writer.Seek(StartPos);
        }
    }
 
    void Rollback()
    {
        Writer.Seek(StartPos);
    }
 
    uint32 GetStartPos() const { return StartPos; }
 
private:
    FNetBitStreamWriter& Writer;
    const uint32 StartPos;
};
 
inline void WriteUint64(FNetBitStreamWriter* Writer, uint64 Value)
{
    Writer->WriteBits((uint32)Value, 32);
    Writer->WriteBits((uint32)(Value >> 32), 32);
}
 
inline uint64 ReadUint64(FNetBitStreamReader* Reader)
{
    uint64 Value = Reader->ReadBits(32);
    uint64 HighValue = Reader->ReadBits(32);
    Value |= HighValue << 32;
 
    return Value;
}
 
inline void WriteInt64(FNetBitStreamWriter* Writer, int64 Value)
{
    WriteUint64(Writer, static_cast<uint64>(Value));
}
 
inline int64 ReadInt64(FNetBitStreamReader* Reader)
{
    uint64 Value = ReadUint64(Reader);
    return static_cast<int64>(Value);
}
 
IRISCORE_API void WritePackedUint64(FNetBitStreamWriter* Writer, uint64 Value);
 
IRISCORE_API uint64 ReadPackedUint64(FNetBitStreamReader* Reader);
 
IRISCORE_API void WritePackedInt64(FNetBitStreamWriter* Writer, int64 Value);
 
IRISCORE_API int64 ReadPackedInt64(FNetBitStreamReader* Reader);
 
IRISCORE_API void WritePackedUint32(FNetBitStreamWriter* Writer, uint32 Value);
 
IRISCORE_API uint32 ReadPackedUint32(FNetBitStreamReader* Reader);
 
IRISCORE_API void WritePackedInt32(FNetBitStreamWriter* Writer, int32 Value);
 
IRISCORE_API int32 ReadPackedInt32(FNetBitStreamReader* Reader);
 
IRISCORE_API void WritePackedUint16(FNetBitStreamWriter* Writer, uint16 Value);
 
IRISCORE_API uint16 ReadPackedUint16(FNetBitStreamReader* Reader);
 
IRISCORE_API void ReadString(FNetBitStreamReader* Reader, FString& OutString);
 
IRISCORE_API void WriteString(FNetBitStreamWriter* Writer, const FString& String);
 
IRISCORE_API void WriteString(FNetBitStreamWriter* Writer, FStringView String);
 
IRISCORE_API void WriteVector(FNetBitStreamWriter* Writer, const FVector& Vector);
 
IRISCORE_API void ReadVector(FNetBitStreamReader* Reader, FVector& Vector);
 
IRISCORE_API void WriteVector(FNetBitStreamWriter* Writer, const FVector& Vector, const FVector& DefaultValue, float Epsilon);
 
IRISCORE_API void ReadVector(FNetBitStreamReader* Reader, FVector& OutVector, const FVector& DefaultValue);
 
IRISCORE_API void WriteRotator(FNetBitStreamWriter* Writer, const FRotator& Vector);
 
IRISCORE_API void ReadRotator(FNetBitStreamReader* Reader, FRotator& Vector);
 
IRISCORE_API void WriteRotator(FNetBitStreamWriter* Writer, const FRotator& Rotator, const FRotator& DefaultValue, float Epsilon);
 
IRISCORE_API void ReadRotator(FNetBitStreamReader* Reader, FRotator& OutRotator, const FRotator& DefaultValue);
 
enum class ESparseBitArraySerializationHint : uint8
{
    None,
    ContainsMostlyOnes,
};
IRISCORE_API void WriteSparseBitArray(FNetBitStreamWriter* Writer, const uint32* Data, uint32 BitCount, ESparseBitArraySerializationHint Hint = ESparseBitArraySerializationHint::None);
 
IRISCORE_API void ReadSparseBitArray(FNetBitStreamReader* Reader,  uint32* OutData, uint32 BitCount, ESparseBitArraySerializationHint Hint = ESparseBitArraySerializationHint::None);
 
IRISCORE_API void WriteSparseBitArrayDelta(FNetBitStreamWriter* Writer, const uint32* Data, const uint32* OldData, uint32 BitCount);
 
IRISCORE_API void ReadSparseBitArrayDelta(FNetBitStreamReader* Reader,  uint32* OutData, const uint32* OldData, uint32 BitCount);
 
IRISCORE_API void WriteSentinelBits(FNetBitStreamWriter* Writer, uint32 BitCount = 32U);
 
IRISCORE_API bool ReadAndVerifySentinelBits(FNetBitStreamReader* Reader, const TCHAR* ErrorString = TEXT("Sentinel"), uint32 BitCount = 32U);
 
IRISCORE_API void WriteBytes(FNetBitStreamWriter* Writer, const uint8* Src, uint32 BytesToWrite);
 
IRISCORE_API void ReadBytes(FNetBitStreamReader* Reader, uint8* Destination, uint32 BytesToRead);
 
IRISCORE_API void WriteConditionallyQuantizedVector(FNetBitStreamWriter* Writer, const FVector& Vector, const FVector& DefaultValue, bool bQuantize);
 
IRISCORE_API void ReadConditionallyQuantizedVector(FNetBitStreamReader* Reader, FVector& OutVector, const FVector& DefaultValue);
 
} // end namespace UE::Net