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*,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