VariableDeltaSerializer.h

Go to the documentation of this file.

#ifndef __VARIABLE_DELTA_SERIALIZER_H
#define __VARIABLE_DELTA_SERIALIZER_H

#include "VariableListDeltaTracker.h"
#include "DS_MemoryPool.h"
#include "NativeTypes.h"
#include "BitStream.h"
#include "PacketPriority.h"
#include "DS_OrderedList.h"

namespace RakNet
{

class VariableDeltaSerializer
{
protected:
    struct RemoteSystemVariableHistory;
    struct ChangedVariablesList;

public:
    VariableDeltaSerializer();
    ~VariableDeltaSerializer();

    struct SerializationContext
    {
        SerializationContext();
        ~SerializationContext();

        RakNetGUID guid;
        BitStream *bitStream;
        uint32_t rakPeerSendReceipt;
        RemoteSystemVariableHistory *variableHistory;
        RemoteSystemVariableHistory *variableHistoryIdentical;
        RemoteSystemVariableHistory *variableHistoryUnique;
        ChangedVariablesList *changedVariables;
        uint32_t sendReceipt;
        PacketReliability serializationMode;
        bool anyVariablesWritten;
        bool newSystemSend; // Force send all, do not record
    };

    struct DeserializationContext
    {
        BitStream *bitStream;
    };

    void BeginUnreliableAckedSerialize(SerializationContext *context, RakNetGUID _guid, BitStream *_bitStream, uint32_t _sendReceipt);

    void BeginUniqueSerialize(SerializationContext *context, RakNetGUID _guid, BitStream *_bitStream);

    void BeginIdenticalSerialize(SerializationContext *context, bool _isFirstSerializeToThisSystem, BitStream *_bitStream);

    void EndSerialize(SerializationContext *context);

    void BeginDeserialize(DeserializationContext *context, BitStream *_bitStream);

    void EndDeserialize(DeserializationContext *context);

    void AddRemoteSystemVariableHistory(RakNetGUID guid);

    void RemoveRemoteSystemVariableHistory(RakNetGUID guid);

    void OnPreSerializeTick(void);

    void OnMessageReceipt(RakNetGUID guid, uint32_t receiptId, bool messageArrived);

    template <class VarType>
    void SerializeVariable(SerializationContext *context, const VarType &variable)
    {
        if (context->newSystemSend)
        {
            if (context->variableHistory->variableListDeltaTracker.IsPastEndOfList()==false)
            {
                // previously sent data to another system
                context->bitStream->Write(true);
                context->bitStream->Write(variable);
                context->anyVariablesWritten=true;
            }
            else
            {
                // never sent data to another system
                context->variableHistory->variableListDeltaTracker.WriteVarToBitstream(variable, context->bitStream);
                context->anyVariablesWritten=true;
            }
        }
        else if (context->serializationMode==UNRELIABLE_WITH_ACK_RECEIPT)
        {
            context->anyVariablesWritten|=
            context->variableHistory->variableListDeltaTracker.WriteVarToBitstream(variable, context->bitStream, context->changedVariables->bitField, context->changedVariables->bitWriteIndex++);
        }
        else
        {
            if (context->variableHistoryIdentical)
            {
                // Identical serialization to a number of systems
                if (didComparisonThisTick==false)
                    context->anyVariablesWritten|=
                    context->variableHistory->variableListDeltaTracker.WriteVarToBitstream(variable, context->bitStream);
                // Else bitstream is written to at the end
            }
            else
            {
                // Per-system serialization
                context->anyVariablesWritten|=
                    context->variableHistory->variableListDeltaTracker.WriteVarToBitstream(variable, context->bitStream);
            }
        }
    }

    template <class VarType>
    bool DeserializeVariable(DeserializationContext *context, VarType &variable)
    {
        return VariableListDeltaTracker::ReadVarFromBitstream(variable, context->bitStream);
    }



protected:

    // For a given send receipt from RakPeer::Send() track which variables we updated
    // That way if that send does not arrive (ID_SND_RECEIPT_LOSS) we can mark those variables as dirty to resend them with current values
    struct ChangedVariablesList
    {
        uint32_t sendReceipt;
        unsigned short bitWriteIndex;
        unsigned char bitField[56];
    };

    // static int Replica2ObjectComp( const uint32_t &key, ChangedVariablesList* const &data );

    static int UpdatedVariablesListPtrComp( const uint32_t &key, ChangedVariablesList* const &data );

    // For each remote system, track the last values of variables we sent to them, and the history of what values changed per call to Send()
    // Every serialize if a variable changes from its last value, send it out again
    // Also if a send does not arrive (ID_SND_RECEIPT_LOSS) we use updatedVariablesHistory to mark those variables as dirty, to resend them unreliably with the current values
    struct RemoteSystemVariableHistory
    {
        RakNetGUID guid;
        VariableListDeltaTracker variableListDeltaTracker;
        DataStructures::OrderedList<uint32_t,ChangedVariablesList*,VariableDeltaSerializer::UpdatedVariablesListPtrComp> updatedVariablesHistory;
    };
    DataStructures::List<RemoteSystemVariableHistory*> remoteSystemVariableHistoryList;

    // Because the ChangedVariablesList is created every serialize and destroyed every receipt I use a pool to avoid fragmentation
    DataStructures::MemoryPool<ChangedVariablesList> updatedVariablesMemoryPool;

    bool didComparisonThisTick;
    RakNet::BitStream identicalSerializationBs;

    void FreeVarsAssociatedWithReceipt(RakNetGUID guid, uint32_t receiptId);
    void DirtyAndFreeVarsAssociatedWithReceipt(RakNetGUID guid, uint32_t receiptId);
    unsigned int GetVarsWrittenPerRemoteSystemListIndex(RakNetGUID guid);
    void RemoveRemoteSystemVariableHistory(void);

    RemoteSystemVariableHistory* GetRemoteSystemVariableHistory(RakNetGUID guid);

    ChangedVariablesList *AllocChangedVariablesList(void);
    void FreeChangedVariablesList(ChangedVariablesList *changedVariables);
    void StoreChangedVariablesList(RemoteSystemVariableHistory *variableHistory, ChangedVariablesList *changedVariables, uint32_t sendReceipt);

    RemoteSystemVariableHistory *StartVariableHistoryWrite(RakNetGUID guid);
    unsigned int GetRemoteSystemHistoryListIndex(RakNetGUID guid);

};

}

#endif