//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ //=============================================================================// #include "dt.h" #include "dt_recv_eng.h" #include "dt_encode.h" #include "dt_instrumentation.h" #include "dt_stack.h" #include "utllinkedlist.h" #include "tier0/dbg.h" #include "dt_recv_decoder.h" #include "tier1/strtools.h" #include "tier0/icommandline.h" #include "dt_common_eng.h" #include "common.h" #include "serializedentity.h" #include "netmessages.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" class CClientSendTable; // Testing out this pattern.. you can write simple code blocks inside of // codeToRun. The thing that sucks is that you can't access your function's // local variables inside of codeToRun. // // If it used an iterator class, it could access local function variables, // but the iterator class might be more trouble than it's worth. #define FOR_EACH_PROP_R( TableType, pTablePointer, tableCode, propCode ) \ class CPropVisitor \ { \ public: \ static void Visit_R( TableType *pTable ) \ { \ tableCode; \ \ for ( int i=0; i < pTable->GetNumProps(); i++ ) \ { \ TableType::PropType *pProp = pTable->GetProp( i ); \ \ propCode; \ \ if ( pProp->GetType() == DPT_DataTable ) \ Visit_R( pProp->GetDataTable() ); \ } \ } \ }; \ CPropVisitor::Visit_R( pTablePointer ); #define SENDPROP_VISIT( pTablePointer, tableCode, propCode ) FOR_EACH_PROP_R( SendTable, pTablePointer, tableCode, propCode ) #define RECVPROP_VISIT( pTablePointer, tableCode, propCode ) FOR_EACH_PROP_R( RecvTable, pTablePointer, tableCode, propCode ) #define SETUP_VISIT() class CDummyClass {} // Workaround for parser bug in VC7.1 // ------------------------------------------------------------------------------------ // // Globals. // ------------------------------------------------------------------------------------ // CUtlLinkedList< RecvTable*, unsigned short > g_RecvTables; CUtlLinkedList< CRecvDecoder *, unsigned short > g_RecvDecoders; CUtlLinkedList< CClientSendTable*, unsigned short > g_ClientSendTables; // ------------------------------------------------------------------------------------ // // Static helper functions. // ------------------------------------------------------------------------------------ // RecvTable* FindRecvTable( const char *pName ) { FOR_EACH_LL( g_RecvTables, i ) { if ( stricmp( g_RecvTables[i]->GetName(), pName ) == 0 ) return g_RecvTables[i]; } return 0; } static CClientSendTable* FindClientSendTable( const char *pName ) { FOR_EACH_LL( g_ClientSendTables, i ) { CClientSendTable *pTable = g_ClientSendTables[i]; if ( stricmp( pTable->GetName(), pName ) == 0 ) return pTable; } return NULL; } // Find all child datatable properties for the send tables. bool SetupClientSendTableHierarchy() { FOR_EACH_LL( g_ClientSendTables, iClientTable ) { CClientSendTable *pTable = g_ClientSendTables[iClientTable]; // For each datatable property, find the table it references. for ( int iProp=0; iProp < pTable->GetNumProps(); iProp++ ) { CClientSendProp *pClientProp = pTable->GetClientProp( iProp ); SendProp *pProp = &pTable->m_SendTable.m_pProps[iProp]; if ( pProp->m_Type == DPT_DataTable ) { const char *pTableName = pClientProp->GetTableName(); ErrorIfNot( pTableName, ("SetupClientSendTableHierarchy: missing table name for prop '%s'.", pProp->GetName()) ); CClientSendTable *pChild = FindClientSendTable( pTableName ); if ( !pChild ) { DataTable_Warning( "SetupClientSendTableHierarchy: missing SendTable '%s' (referenced by '%s').\n", pTableName, pTable->GetName() ); return false; } pProp->SetDataTable( &pChild->m_SendTable ); } } } return true; } static RecvProp* FindRecvProp( RecvTable *pTable, const char *pName ) { for ( int i=0; i < pTable->GetNumProps(); i++ ) { RecvProp *pProp = pTable->GetProp( i ); #ifdef DBGFLAG_ASSERT // Debug validation to handle that no network fields get created with colliding names to special UTL vector networking fields // because we will have custom receive table remapping below and don't want to mistakenly route bytes into wrong memory // See dt_utlvector_recv.cpp / RecvPropUtlVector for details of this remapping if ( char const *szLength = StringAfterPrefix( pProp->GetName(), "lengthprop" ) ) { // *pLengthProp = RecvPropInt( AllocateStringHelper( "lengthprop%d", nMaxElements ), 0, 0, 0, RecvProxy_UtlVectorLength ); Assert( pProp->GetType() == DPT_Int ); Assert( *szLength ); for ( char const *szCheck = szLength; szCheck && *szCheck; ++ szCheck ) { Assert( V_isdigit( *szCheck ) ); // assert that the number forms the length of array Assert( szCheck - szLength < 5 ); // arrays are never that large! } } else if ( char const *szLPT = StringAfterPrefix( pProp->GetName(), "_LPT_" ) ) { // char *pLengthProxyTableName = AllocateUniqueDataTableName( false, "_LPT_%s_%d", pVarName, nMaxElements ); Assert( pProp->GetType() == DPT_DataTable ); char const *szLPTsize = strrchr( szLPT, '_' ); Assert( szLPTsize ); if ( szLPTsize ) { ++ szLPTsize; Assert( *szLPTsize ); } for ( char const *szCheck = szLPTsize; szCheck && *szCheck; ++szCheck ) { Assert( V_isdigit( *szCheck ) ); // assert that the number forms the length of array Assert( szCheck - szLength < 5 ); // arrays are never that large! } } else if ( char const *szST = StringAfterPrefix( pProp->GetName(), "_ST_" ) ) { // AllocateUniqueDataTableName( false, "_ST_%s_%d", pVarName, nMaxElements ) Assert( pProp->GetType() == DPT_DataTable ); char const *szSTsize = strrchr( szST, '_' ); Assert( szSTsize ); if ( szSTsize ) { ++szSTsize; Assert( *szSTsize ); } for ( char const *szCheck = szSTsize; szCheck && *szCheck; ++szCheck ) { Assert( V_isdigit( *szCheck ) ); // assert that the number forms the length of array Assert( szCheck - szLength < 5 ); // arrays are never that large! } } #endif if ( !V_stricmp( pProp->GetName(), pName ) ) return pProp; // // Special case to receive UTL vector networked prop into a larger UTL vector networked prop on the client // See dt_utlvector_recv.cpp / RecvPropUtlVector for details of this remapping // if ( char const *p_SEND_Length = StringAfterPrefix( pName, "lengthprop" ) ) { // We are being sent a lengthprop## if ( char const *p_RECV_Length = StringAfterPrefix( pProp->GetName(), "lengthprop" ) ) { if ( Q_atoi( p_SEND_Length ) <= Q_atoi( p_RECV_Length ) ) return pProp; } } else if ( char const *p_SEND_LPT = StringAfterPrefix( pName, "_LPT_" ) ) { // We are being sent an _LPT_(varname)_## field if ( char const *p_RECV_LPT = StringAfterPrefix( pProp->GetName(), "_LPT_" ) ) { // Trim the length from the field char const *p_SEND_LPT_size = strrchr( p_SEND_LPT, '_' ); char const *p_RECV_LPT_size = strrchr( p_RECV_LPT, '_' ); if ( p_SEND_LPT_size && p_RECV_LPT_size && ( p_SEND_LPT_size - p_SEND_LPT == p_RECV_LPT_size - p_RECV_LPT ) && !V_strnicmp( p_SEND_LPT, p_RECV_LPT, p_RECV_LPT_size - p_RECV_LPT ) && ( Q_atoi( p_SEND_LPT_size + 1 ) <= Q_atoi( p_RECV_LPT_size + 1 ) ) ) return pProp; } } else if ( char const *p_SEND_ST = StringAfterPrefix( pName, "_ST_" ) ) { // We are being sent an _ST_(varname)_## field if ( char const *p_RECV_ST = StringAfterPrefix( pProp->GetName(), "_ST_" ) ) { // Trim the length from the field char const *p_SEND_ST_size = strrchr( p_SEND_ST, '_' ); char const *p_RECV_ST_size = strrchr( p_RECV_ST, '_' ); if ( p_SEND_ST_size && p_RECV_ST_size && ( p_SEND_ST_size - p_SEND_ST == p_RECV_ST_size - p_RECV_ST ) && !V_strnicmp( p_SEND_ST, p_RECV_ST, p_RECV_ST_size - p_RECV_ST ) && ( Q_atoi( p_SEND_ST_size + 1 ) <= Q_atoi( p_RECV_ST_size + 1 ) ) ) return pProp; } } // // End of UTL vector backwards compatibility receiving remap // } // Support recursing into base classes to find the required field: if ( pTable->GetNumProps() ) { RecvProp *pSubProp = pTable->GetProp( 0 ); if ( ( pSubProp->GetType() == DPT_DataTable ) && !V_stricmp( pSubProp->GetName(), "baseclass" ) ) return FindRecvProp( pSubProp->GetDataTable(), pName ); } return NULL; } // See if the RecvProp is fit to receive the SendProp's data. bool CompareRecvPropToSendProp( const RecvProp *pRecvProp, const SendProp *pSendProp ) { while ( 1 ) { ErrorIfNot( pRecvProp && pSendProp, ("CompareRecvPropToSendProp: missing a property.") ); if ( pRecvProp->GetType() != pSendProp->GetType() || pRecvProp->IsInsideArray() != pSendProp->IsInsideArray() ) { return false; } if ( pRecvProp->GetType() == DPT_Array ) { // It should be OK to receive into a larger array, just later elements // will not ever be received if ( pRecvProp->GetNumElements() < pSendProp->GetNumElements() ) return false; pRecvProp = pRecvProp->GetArrayProp(); pSendProp = pSendProp->GetArrayProp(); } else { return true; } } } struct MatchingProp_t { SendProp *m_pProp; RecvProp *m_pMatchingRecvProp; static bool LessFunc( const MatchingProp_t& lhs, const MatchingProp_t& rhs ) { return lhs.m_pProp < rhs.m_pProp; } }; static bool MatchRecvPropsToSendProps_R( CUtlRBTree< MatchingProp_t, unsigned short >& lookup, char const *sendTableName, SendTable *pSendTable, RecvTable *pRecvTable, bool bAllowMismatches, bool *pAnyMismatches ) { for ( int i=0; i < pSendTable->m_nProps; i++ ) { SendProp *pSendProp = &pSendTable->m_pProps[i]; if ( pSendProp->IsExcludeProp() || pSendProp->IsInsideArray() ) continue; // Find a RecvProp by the same name and type. RecvProp *pRecvProp = 0; if ( pRecvTable ) pRecvProp = FindRecvProp( pRecvTable, pSendProp->GetName() ); if ( pRecvProp ) { if ( !CompareRecvPropToSendProp( pRecvProp, pSendProp ) ) { Warning( "RecvProp type doesn't match server type for %s/%s\n", pSendTable->GetName(), pSendProp->GetName() ); return false; } MatchingProp_t info; info.m_pProp = pSendProp; info.m_pMatchingRecvProp = pRecvProp; lookup.Insert( info ); } else { if ( pAnyMismatches ) { *pAnyMismatches = true; } DevWarning( "Missing RecvProp for %s - %s/%s\n", sendTableName, pSendTable->GetName(), pSendProp->GetName() ); if ( !bAllowMismatches ) { return false; } } // Recurse. if ( pSendProp->GetType() == DPT_DataTable ) { if ( !MatchRecvPropsToSendProps_R( lookup, sendTableName, pSendProp->GetDataTable(), pRecvProp ? pRecvProp->GetDataTable() : 0, bAllowMismatches, pAnyMismatches ) ) return false; } } return true; } extern bool s_debug_info_shown; extern int s_debug_bits_start; static inline void ShowDecodeDeltaWatchInfo( char *what, const RecvTable *pTable, const SendProp *pProp, bf_read &buffer, const int objectID, const int index ) { if ( !ShouldWatchThisProp( pTable, objectID, pProp->GetName()) ) return; extern int host_framecount; static int lastframe = -1; if ( host_framecount != lastframe ) { lastframe = host_framecount; ConDMsg( "D: delta entity: %i %s\n", objectID, pTable->GetName() ); } // work on copy of bitbuffer bf_read copy = buffer; s_debug_info_shown = true; DecodeInfo info; info.m_pStruct = NULL; info.m_pData = NULL; info.m_pRecvProp = NULL; info.m_pProp = pProp; info.m_pIn = © info.m_ObjectID = objectID; info.m_Value.m_Type = (SendPropType)pProp->m_Type; int startBit = copy.GetNumBitsRead(); g_PropTypeFns[pProp->m_Type].Decode( &info ); int bits = copy.GetNumBitsRead() - startBit; const char *type = g_PropTypeFns[pProp->m_Type].GetTypeNameString(); const char *value = info.m_Value.ToString(); ConDMsg( "D[%s]:%s %s, %s, index %i, offset %i, bits %i, value %s\n", what, pTable->GetName(), pProp->GetName(), type, index, startBit, bits, value ); } // ------------------------------------------------------------------------------------ // // Interface functions. // ------------------------------------------------------------------------------------ // bool RecvTable_Init( RecvTable **pTables, int nTables ) { SETUP_VISIT(); for ( int i=0; i < nTables; i++ ) { RECVPROP_VISIT( pTables[i], { if ( pTable->IsInMainList() ) return; // Shouldn't have a decoder yet. ErrorIfNot( !pTable->m_pDecoder, ("RecvTable_Init: table '%s' has a decoder already.", pTable->GetName())); pTable->SetInMainList( true ); g_RecvTables.AddToTail( pTable ); }, {} ); } return true; } void RecvTable_Term( bool clearall /*= true*/ ) { DTI_Term(); SETUP_VISIT(); FOR_EACH_LL( g_RecvTables, i ) { RECVPROP_VISIT( g_RecvTables[i], { if ( !pTable->IsInMainList() ) return; pTable->SetInMainList( false ); pTable->m_pDecoder = 0; }, {} ); } if ( clearall ) { g_RecvTables.Purge(); } g_RecvDecoders.PurgeAndDeleteElements(); g_ClientSendTables.PurgeAndDeleteElements(); } void RecvTable_FreeSendTable( SendTable *pTable ) { for ( int iProp=0; iProp < pTable->m_nProps; iProp++ ) { SendProp *pProp = &pTable->m_pProps[iProp]; delete [] pProp->m_pVarName; if ( pProp->m_pExcludeDTName ) delete [] pProp->m_pExcludeDTName; } if ( pTable->m_pProps ) delete [] pTable->m_pProps; delete [] pTable->m_pNetTableName; delete pTable; } static char* AllocString( const char *pStr ) { int allocLen = strlen( pStr ) + 1; char *pOut = new char[allocLen]; V_strncpy( pOut, pStr, allocLen ); return pOut; } SendTable *RecvTable_ReadInfos( const CSVCMsg_SendTable& msg, int nDemoProtocol ) { SendTable *pTable = new SendTable; pTable->m_pNetTableName = AllocString( msg.net_table_name().c_str() ); // Read the property list. pTable->m_nProps = msg.props_size(); pTable->m_pProps = pTable->m_nProps ? new SendProp[ pTable->m_nProps ] : NULL; for ( int iProp=0; iProp < pTable->m_nProps; iProp++ ) { SendProp *pProp = &pTable->m_pProps[iProp]; const CSVCMsg_SendTable::sendprop_t& sendProp = msg.props( iProp ); pProp->m_Type = (SendPropType)sendProp.type(); pProp->m_pVarName = AllocString( sendProp.var_name().c_str() ); pProp->SetFlags( sendProp.flags() ); pProp->SetPriority( sendProp.priority() ); if ( ( pProp->m_Type == DPT_DataTable ) || ( pProp->IsExcludeProp() ) ) { pProp->m_pExcludeDTName = AllocString( sendProp.dt_name().c_str() ); } else if ( pProp->GetType() == DPT_Array ) { pProp->SetNumElements( sendProp.num_elements() ); } else { pProp->m_fLowValue = sendProp.low_value(); pProp->m_fHighValue = sendProp.high_value(); pProp->m_nBits = sendProp.num_bits(); } } return pTable; } bool RecvTable_RecvClassInfos( const CSVCMsg_SendTable& msg, int nDemoProtocol ) { SendTable *pSendTable = RecvTable_ReadInfos( msg, nDemoProtocol ); if ( !pSendTable ) return false; bool ret = DataTable_SetupReceiveTableFromSendTable( pSendTable, msg.needs_decoder() ); RecvTable_FreeSendTable( pSendTable ); return ret; } static void CopySendPropsToRecvProps( CUtlRBTree< MatchingProp_t, unsigned short >& lookup, const CUtlVector &sendProps, CUtlVector &recvProps ) { recvProps.SetSize( sendProps.Count() ); for ( int iSendProp=0; iSendProp < sendProps.Count(); iSendProp++ ) { const SendProp *pSendProp = sendProps[iSendProp]; MatchingProp_t search; search.m_pProp = (SendProp *)pSendProp; int idx = lookup.Find( search ); if ( idx == lookup.InvalidIndex() ) { recvProps[iSendProp] = 0; } else { recvProps[iSendProp] = lookup[ idx ].m_pMatchingRecvProp; } } } bool RecvTable_CreateDecoders( const CStandardSendProxies *pSendProxies, bool bAllowMismatches, bool *pAnyMismatches ) { DTI_Init(); SETUP_VISIT(); if ( pAnyMismatches ) { *pAnyMismatches = false; } // First, now that we've supposedly received all the SendTables that we need, // set their datatable child pointers. if ( !SetupClientSendTableHierarchy() ) return false; bool bRet = true; FOR_EACH_LL( g_RecvDecoders, i ) { CRecvDecoder *pDecoder = g_RecvDecoders[i]; // It should already have been linked to its ClientSendTable. Assert( pDecoder->m_pClientSendTable ); if ( !pDecoder->m_pClientSendTable ) return false; // For each decoder, precalculate the SendTable's flat property list. if ( !pDecoder->m_Precalc.SetupFlatPropertyArray() ) return false; CUtlRBTree< MatchingProp_t, unsigned short > PropLookup( 0, 0, MatchingProp_t::LessFunc ); // Now match RecvProp with SendProps. if ( !MatchRecvPropsToSendProps_R( PropLookup, pDecoder->GetSendTable()->m_pNetTableName, pDecoder->GetSendTable(), pDecoder->GetRecvTable(), bAllowMismatches, pAnyMismatches ) ) { bRet = false; } else { // Now fill out the matching RecvProp array. CSendTablePrecalc *pPrecalc = &pDecoder->m_Precalc; CopySendPropsToRecvProps( PropLookup, pPrecalc->m_Props, pDecoder->m_Props ); CopySendPropsToRecvProps( PropLookup, pPrecalc->m_DatatableProps, pDecoder->m_DatatableProps ); DTI_HookRecvDecoder( pDecoder ); } } return bRet; } bool RecvTable_Decode( RecvTable *pTable, void *pStruct, SerializedEntityHandle_t dest, int objectID ) { CRecvDecoder *pDecoder = pTable->m_pDecoder; ErrorIfNot( pDecoder, ("RecvTable_Decode: table '%s' missing a decoder.", pTable->GetName()) ); CSerializedEntity *pEntity = reinterpret_cast< CSerializedEntity * >( dest ); Assert( pEntity ); // While there are properties, decode them.. walk the stack as you go. CClientDatatableStack theStack( pDecoder, (unsigned char*)pStruct, objectID ); theStack.Init( false, false ); bf_read buf; buf.SetDebugName( "CFlattenedSerializer::Decode" ); pEntity->StartReading( buf ); CFieldPath path; int nDataOffset; int nNextDataOffset; for ( int nFieldIndex = 0 ; nFieldIndex < pEntity->GetFieldCount() ; ++nFieldIndex ) { pEntity->GetField( nFieldIndex, path, &nDataOffset, &nNextDataOffset ); buf.Seek( nDataOffset ); theStack.SeekToProp( path ); const RecvProp *pProp = pDecoder->GetProp( path ); DecodeInfo decodeInfo; decodeInfo.m_pStruct = theStack.GetCurStructBase(); if ( pProp ) { decodeInfo.m_pData = theStack.GetCurStructBase() + pProp->GetOffset(); } else { // They're allowed to be missing props here if they're playing back a demo. // This allows us to change the datatables and still preserve old demos. decodeInfo.m_pData = NULL; } decodeInfo.m_pRecvProp = theStack.IsCurProxyValid() ? pProp : NULL; // Just skip the data if the proxies are screwed. decodeInfo.m_pProp = pDecoder->GetSendProp( path ); decodeInfo.m_pIn = &buf; decodeInfo.m_ObjectID = objectID; g_PropTypeFns[ decodeInfo.m_pProp->GetType() ].Decode( &decodeInfo ); } return !buf.IsOverflowed(); } void RecvTable_DecodeZeros( RecvTable *pTable, void *pStruct, int objectID ) { CRecvDecoder *pDecoder = pTable->m_pDecoder; ErrorIfNot( pDecoder, ("RecvTable_DecodeZeros: table '%s' missing a decoder.", pTable->GetName()) ); // While there are properties, decode them.. walk the stack as you go. CClientDatatableStack theStack( pDecoder, (unsigned char*)pStruct, objectID ); theStack.Init( false, false ); for ( int iProp=0; iProp < pDecoder->GetNumProps(); iProp++ ) { theStack.SeekToProp( iProp ); const RecvProp *pProp = pDecoder->GetProp( iProp ); DecodeInfo decodeInfo; decodeInfo.m_pStruct = theStack.GetCurStructBase(); decodeInfo.m_pData = theStack.GetCurStructBase() + pProp->GetOffset(); decodeInfo.m_pRecvProp = theStack.IsCurProxyValid() ? pProp : NULL; // Just skip the data if the proxies are screwed. decodeInfo.m_pProp = pDecoder->GetSendProp( iProp ); decodeInfo.m_pIn = NULL; decodeInfo.m_ObjectID = objectID; g_PropTypeFns[pProp->GetType()].DecodeZero( &decodeInfo ); } } // Copies pProp's state from pIn to pOut. pDecodeInfo MUST be setup by calling InitDecodeInfoForSkippingProps // with pIn. // // NOTE: this routine isn't optimal. If it shows up on the profiles, then it's easy to // make this fast by adding a special routine to copy a property's state to PropTypeFns. static void CopyPropState( CRecvDecoder *pDecoder, int iSendProp, bf_read *pIn, CDeltaBitsWriter *pOut ) { const SendProp *pProp = pDecoder->GetSendProp( iSendProp ); int iStartBit = pIn->GetNumBitsRead(); // skip over data SkipPropData( pIn, pProp ); // Figure out how many bits it took. int nBits = pIn->GetNumBitsRead() - iStartBit; // Copy the data pIn->Seek( iStartBit ); pOut->WritePropIndex( iSendProp ); pOut->GetBitBuf()->WriteBitsFromBuffer( pIn, nBits ); } bool RecvTable_MergeDeltas( RecvTable *pTable, SerializedEntityHandle_t oldState, // Can be invalid SerializedEntityHandle_t newState, SerializedEntityHandle_t mergedState, int objectID, CUtlVector< int > *pVecChanges ) { Assert( SERIALIZED_ENTITY_HANDLE_INVALID != newState ); Assert( SERIALIZED_ENTITY_HANDLE_INVALID != mergedState ); CSerializedEntity *pOldState = oldState != SERIALIZED_ENTITY_HANDLE_INVALID ? reinterpret_cast< CSerializedEntity * >( oldState ) : NULL; CSerializedEntity *pNewState = reinterpret_cast< CSerializedEntity * >( newState ); Assert( pNewState ); CSerializedEntity *pMergedState = reinterpret_cast< CSerializedEntity * >( mergedState ); Assert( pMergedState ); ErrorIfNot( pTable && pNewState && pMergedState, ("RecvTable_MergeDeltas: invalid parameters passed.") ); CRecvDecoder *pDecoder = pTable->m_pDecoder; ErrorIfNot( pDecoder, ("RecvTable_MergeDeltas: table '%s' is missing its decoder.", pTable->GetName()) ); CSerializedEntityFieldIterator oldIterator( pOldState ); CSerializedEntityFieldIterator newIterator( pNewState ); bf_read oldBits, newBits; oldBits.SetDebugName( "CFlattenedSerializer::MergeDeltas: oldBits" ); newBits.SetDebugName( "CFlattenedSerializer::MergeDeltas: newBits" ); if ( pOldState ) { pOldState->StartReading( oldBits ); } pNewState->StartReading( newBits ); pMergedState->Clear(); const CFieldPath *oldFieldPath = oldIterator.FirstPtr(); const CFieldPath *newFieldPath = newIterator.FirstPtr(); uint8 packedData[MAX_PACKEDENTITY_DATA]; bf_write fieldDataBuf( "CFlattenedSerializer::WriteFieldList fieldDataBuf", packedData, sizeof( packedData ) ); while ( 1 ) { // Write any properties in the previous state that aren't in the new state. while ( *oldFieldPath < *newFieldPath ) { pMergedState->AddPathAndOffset( *oldFieldPath, fieldDataBuf.GetNumBitsWritten() ); oldBits.Seek( oldIterator.GetOffset() ); fieldDataBuf.WriteBitsFromBuffer( &oldBits, oldIterator.GetLength() ); oldFieldPath = oldIterator.NextPtr(); } if ( *newFieldPath == PROP_SENTINEL ) break; // Check if we're at the end here so the while() statement above can seek the old buffer // to its end too. bool bBoth = ( *oldFieldPath == *newFieldPath ); // If the old state has this property too, then just skip over its data. if ( bBoth ) { oldFieldPath = oldIterator.NextPtr(); } pMergedState->AddPathAndOffset( *newFieldPath, fieldDataBuf.GetNumBitsWritten() ); newBits.Seek( newIterator.GetOffset() ); fieldDataBuf.WriteBitsFromBuffer( &newBits, newIterator.GetLength() ); if ( pVecChanges ) { pVecChanges->AddToTail( *newFieldPath ); } newFieldPath = newIterator.NextPtr(); } pMergedState->PackWithFieldData( packedData, fieldDataBuf.GetNumBitsWritten() ); ErrorIfNot( !fieldDataBuf.IsOverflowed(), ("RecvTable_MergeDeltas: overflowed in RecvTable '%s'.", pTable->GetName() ) ); return true; } template< bool bDTIEnabled > bool RecvTable_ReadFieldList_Guts( RecvTable *pTable, bf_read &buf, SerializedEntityHandle_t dest, int nObjectId ) { CSerializedEntity *pEntity = reinterpret_cast< CSerializedEntity * >( dest ); Assert( pEntity ); pEntity->Clear(); CUtlVector< int > fieldBits; pEntity->ReadFieldPaths( &buf, bDTIEnabled ? &fieldBits : NULL ); ErrorIfNot( pTable, ("RecvTable_ReadFieldListt: Missing RecvTable for class\n" ) ); if ( !pTable ) return false; CRecvDecoder *pDecoder = pTable->m_pDecoder; ErrorIfNot( pDecoder, ("RecvTable_ReadFieldList: table '%s' missing a decoder.", pTable->GetName()) ); // Remember where the "data" payload started int nStartBit = buf.GetNumBitsRead(); CFieldPath path; for ( int nFieldIndex = 0; nFieldIndex < pEntity->GetFieldCount(); ++nFieldIndex ) { int nDataOffset = buf.GetNumBitsRead(); path = pEntity->GetFieldPath( nFieldIndex ); pEntity->SetFieldDataBitOffset( nFieldIndex, nDataOffset - nStartBit ); // Offset from start of data payload const SendProp *pSendProp = pDecoder->GetSendProp( path ); g_PropTypeFns[ pSendProp->GetType() ].SkipProp( pSendProp, &buf ); // buffer now just after payload if ( bDTIEnabled ) { DTI_HookDeltaBits( pDecoder, path, buf.GetNumBitsRead() - nDataOffset, fieldBits[ nFieldIndex ] ); } } int nLastBit = buf.GetNumBitsRead(); // Rewind buf.Seek( nStartBit ); // Copy pEntity->PackWithFieldData( buf, nLastBit - nStartBit ); // Put head back to end buf.Seek( nLastBit ); return true; } bool RecvTable_ReadFieldList( RecvTable *pTable, bf_read &buf, SerializedEntityHandle_t dest, int nObjectId, bool bUpdateDTI ) { if ( g_bDTIEnabled && bUpdateDTI ) { return RecvTable_ReadFieldList_Guts< true >( pTable, buf, dest, nObjectId ); } return RecvTable_ReadFieldList_Guts< false >( pTable, buf, dest, nObjectId ); }